<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=2">
<meta name="theme-color" content="#222">
<meta name="generator" content="Hexo 5.4.0">
  <link rel="apple-touch-icon" sizes="180x180" href="/blogwebpage/images/apple-touch-icon-next.png">
  <link rel="icon" type="image/png" sizes="32x32" href="/blogwebpage/images/favicon.ico">
  <link rel="icon" type="image/png" sizes="16x16" href="/blogwebpage/images/favicon.ico">
  <link rel="mask-icon" href="/blogwebpage/images/logo.svg" color="#222">
  <meta name="msvalidate.01" content="9BDlx6FiNE">

<link rel="stylesheet" href="/blogwebpage/css/main.css">


<link rel="stylesheet" href="/blogwebpage/lib/font-awesome/css/all.min.css">

<script id="hexo-configurations">
    var NexT = window.NexT || {};
    var CONFIG = {"hostname":"wangkejie.gitee.io","root":"/blogwebpage/","scheme":"Gemini","version":"7.8.0","exturl":true,"sidebar":{"position":"left","display":"post","padding":18,"offset":12,"onmobile":false},"copycode":{"enable":true,"show_result":true,"style":"default"},"back2top":{"enable":true,"sidebar":false,"scrollpercent":false},"bookmark":{"enable":false,"color":"#222","save":"auto"},"fancybox":false,"mediumzoom":false,"lazyload":false,"pangu":false,"comments":{"style":"tabs","active":null,"storage":true,"lazyload":false,"nav":null},"algolia":{"hits":{"per_page":10},"labels":{"input_placeholder":"Search for Posts","hits_empty":"We didn't find any results for the search: ${query}","hits_stats":"${hits} results found in ${time} ms"}},"localsearch":{"enable":true,"trigger":"auto","top_n_per_article":1,"unescape":false,"preload":false},"motion":{"enable":true,"async":false,"transition":{"post_block":"fadeIn","post_header":"slideDownIn","post_body":"slideDownIn","coll_header":"slideLeftIn","sidebar":"slideUpIn"}},"path":"search.xml"};
  </script>

  <meta name="description" content="书山有路勤为径，学海无涯苦作舟！">
<meta property="og:type" content="website">
<meta property="og:title" content="王科杰">
<meta property="og:url" content="https://wangkejie.gitee.io/blogwebpage/index.html">
<meta property="og:site_name" content="王科杰">
<meta property="og:description" content="书山有路勤为径，学海无涯苦作舟！">
<meta property="og:locale" content="zh_CN">
<meta property="article:author" content="Jack Wang">
<meta name="twitter:card" content="summary">

<link rel="canonical" href="https://wangkejie.gitee.io/blogwebpage/">


<script id="page-configurations">
  // https://hexo.io/docs/variables.html
  CONFIG.page = {
    sidebar: "",
    isHome : true,
    isPost : false,
    lang   : 'zh-CN'
  };
</script>

  <title>王科杰 - Jack's Notes</title>
  


  <script>
    var _hmt = _hmt || [];
    (function() {
      var hm = document.createElement("script");
      hm.src = "https://hm.baidu.com/hm.js?93e26277de0cf2c5851167f2c6dcaa7d";
      var s = document.getElementsByTagName("script")[0];
      s.parentNode.insertBefore(hm, s);
    })();
  </script>




  <noscript>
  <style>
  .use-motion .brand,
  .use-motion .menu-item,
  .sidebar-inner,
  .use-motion .post-block,
  .use-motion .pagination,
  .use-motion .comments,
  .use-motion .post-header,
  .use-motion .post-body,
  .use-motion .collection-header { opacity: initial; }

  .use-motion .site-title,
  .use-motion .site-subtitle {
    opacity: initial;
    top: initial;
  }

  .use-motion .logo-line-before i { left: initial; }
  .use-motion .logo-line-after i { right: initial; }
  </style>
</noscript>

</head>

<body itemscope itemtype="http://schema.org/WebPage">
  <div class="container use-motion">
    <div class="headband"></div>

    <header class="header" itemscope itemtype="http://schema.org/WPHeader">
      <div class="header-inner"><div class="site-brand-container">
  <div class="site-nav-toggle">
    <div class="toggle" aria-label="切换导航栏">
      <span class="toggle-line toggle-line-first"></span>
      <span class="toggle-line toggle-line-middle"></span>
      <span class="toggle-line toggle-line-last"></span>
    </div>
  </div>

  <div class="site-meta">

    <a href="/blogwebpage/" class="brand" rel="start">
      <span class="logo-line-before"><i></i></span>
      <h1 class="site-title">王科杰</h1>
      <span class="logo-line-after"><i></i></span>
    </a>
      <p class="site-subtitle" itemprop="description">Jack's Notes</p>
  </div>

  <div class="site-nav-right">
    <div class="toggle popup-trigger">
        <i class="fa fa-search fa-fw fa-lg"></i>
    </div>
  </div>
</div>




<nav class="site-nav">
  <ul id="menu" class="main-menu menu">
        <li class="menu-item menu-item-home">

    <a href="/blogwebpage/" rel="section"><i class="home fa-fw"></i>首页</a>

  </li>
        <li class="menu-item menu-item-archives">

    <a href="/blogwebpage/archives/" rel="section"><i class="archive fa-fw"></i>归档<span class="badge">52</span></a>

  </li>
        <li class="menu-item menu-item-about">

    <a href="/blogwebpage/me/" rel="section"><i class="user fa-fw"></i>关于</a>

  </li>
        <li class="menu-item menu-item-tags">

    <a href="/blogwebpage/tags/" rel="section"><i class="tags fa-fw"></i>标签<span class="badge">54</span></a>

  </li>
        <li class="menu-item menu-item-categories">

    <a href="/blogwebpage/categories/" rel="section"><i class="th fa-fw"></i>分类<span class="badge">56</span></a>

  </li>
      <li class="menu-item menu-item-search">
        <a role="button" class="popup-trigger"><i class="fa fa-search fa-fw"></i>搜索
        </a>
      </li>
  </ul>
</nav>



  <div class="search-pop-overlay">
    <div class="popup search-popup">
        <div class="search-header">
  <span class="search-icon">
    <i class="fa fa-search"></i>
  </span>
  <div class="search-input-container">
    <input autocomplete="off" autocapitalize="off"
           placeholder="搜索..." spellcheck="false"
           type="search" class="search-input">
  </div>
  <span class="popup-btn-close">
    <i class="fa fa-times-circle"></i>
  </span>
</div>
<div id="search-result">
  <div id="no-result">
    <i class="fa fa-spinner fa-pulse fa-5x fa-fw"></i>
  </div>
</div>

    </div>
  </div>

</div>
    </header>

    
  <div class="back-to-top">
    <i class="fa fa-arrow-up"></i>
    <span>0%</span>
  </div>

  <span class="exturl github-corner" data-url="aHR0cHM6Ly9naXRodWIuY29tL0phY2stVmluZw==" title="Follow me on GitHub" aria-label="Follow me on GitHub"><svg width="80" height="80" viewBox="0 0 250 250" aria-hidden="true"><path d="M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z"></path><path d="M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2" fill="currentColor" style="transform-origin: 130px 106px;" class="octo-arm"></path><path d="M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z" fill="currentColor" class="octo-body"></path></svg></span>


    <main class="main">
      <div class="main-inner">
        <div class="content-wrap">
          

          <div class="content index posts-expand">
            
      
  
  
  <article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-CN">
    <link itemprop="mainEntityOfPage" href="https://wangkejie.gitee.io/blogwebpage/home.html">

    <span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
      <meta itemprop="image" content="/blogwebpage/images/avatar.gif">
      <meta itemprop="name" content="Jack Wang">
      <meta itemprop="description" content="书山有路勤为径，学海无涯苦作舟！">
    </span>

    <span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
      <meta itemprop="name" content="王科杰">
    </span>
      <header class="post-header">
        <h2 class="post-title" itemprop="name headline">
          
            <a href="/blogwebpage/home.html" class="post-title-link" itemprop="url">我的博客首页</a>
        </h2>

        <div class="post-meta">
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-calendar"></i>
              </span>
              <span class="post-meta-item-text">发表于</span>

              <time title="创建时间：9999-12-31 00:00:00" itemprop="dateCreated datePublished" datetime="9999-12-31T00:00:00+08:00">9999-12-31</time>
            </span>

          

        </div>
      </header>

    
    
    
    <div class="post-body" itemprop="articleBody">

      
          <h1 id="欢迎来到我的博客"><a href="#欢迎来到我的博客" class="headerlink" title="欢迎来到我的博客"></a>欢迎来到我的博客</h1><blockquote>
<p>学习一些东西，记录一些东西，刚开始搭建，有好的建议联系我 <span class="exturl" data-url="bWFpbHRvOiYjeDM3OyYjNTA7JiN4Mzc7JiN4Mzg7JiN4Mzg7JiM0OTsmI3gzOTsmIzUyOyYjeDM1OyYjeDQwOyYjeDcxOyYjeDcxOyYjNDY7JiM5OTsmI3g2ZjsmIzEwOTs=">&#x37;&#50;&#x37;&#x38;&#x38;&#49;&#x39;&#52;&#x35;&#x40;&#x71;&#x71;&#46;&#99;&#x6f;&#109;<i class="fa fa-external-link-alt"></i></span></p>
</blockquote>
<h2 id="iOS-程序崩溃抓取与分析（后续再写一些其它的东西）"><a href="#iOS-程序崩溃抓取与分析（后续再写一些其它的东西）" class="headerlink" title="iOS 程序崩溃抓取与分析（后续再写一些其它的东西）"></a>iOS 程序崩溃抓取与分析（后续再写一些其它的东西）</h2><p>初学者，或再深入了解iOS的朋友，请查看下面《关于iOS基础技术部分》相关知识点。</p>
<blockquote>
<p><a href="./iOS/crashreport/crashanalysis.html">iOS中，程序崩溃，抓取过程与分析, 点击查看</a></p>
</blockquote>
<h2 id="关于iOS基础技术部分"><a href="#关于iOS基础技术部分" class="headerlink" title="关于iOS基础技术部分"></a>关于iOS基础技术部分</h2><ul>
<li>你可以点击<a href="./categories/">iOS目录</a>，查看更详细的大纲<ul>
<li><a href="./iOS/objective-c/index.html">OC相关基础</a></li>
<li><a href="./iOS/multithreading/index.html">多线程</a></li>
<li><a href="./iOS/RunTime/index.html">RunTime</a></li>
<li><a href="./iOS/RunLoop/index.html">RunLoop</a></li>
<li><a href="./iOS/block/index.html">block相关</a></li>
<li><a href="./iOS/animation/index.html">animation动画</a></li>
<li><a href="./iOS/algorithm/index.html">算法收集</a></li>
<li><a href="./iOS/memorymanagerment/memory.html">内存管理</a></li>
<li><a href="./iOS/performance/index.html">iOS优化</a></li>
<li><a href="./iOS/kernelarchitecture/overview.html">苹果内核架构</a></li>
<li><a href="./iOS/kernelarchitecture/mach.html">mach内核</a></li>
<li><a href="./iOS/thirdpart/asdk.html">AsyncDisplayKit</a></li>
<li><a href="./iOS/hybrid/hybrid.html">Hybrid浅谈</a></li>
</ul>
</li>
<li>慕课网视频，学习笔记，<a href="./iOS/study.html">点击查看笔记</a></li>
<li>面试可能会问到的东西，<a href="./iOS/interview/index.html">中高级面试</a></li>
<li><a href="./categories/iOS/%E6%BA%90%E7%A0%81%E5%AD%A6%E4%B9%A0/">iOS源码学习</a><ul>
<li><a href="./iOS/origincode/metaclass.html">什么是元类</a></li>
<li><a href="./iOS/origincode/origincodestudy.html">类的本质</a></li>
<li><a href="./iOS/origincode/category.html">分类</a></li>
</ul>
</li>
<li><a href="./categories/iOS/Third-Party-Lib/">第三方库学习</a><ul>
<li><a href="./iOS/thirdpart/sdwebimage.html">SDWebImage</a></li>
<li><a href="iOS/thirdpart/glide.html">Glide</a></li>
</ul>
</li>
<li><a href="./categories/OS/">操作系统</a><ul>
<li><a href="os/ios-macos.html">MacOS和iOS操作系统</a></li>
</ul>
</li>
</ul>
<h2 id="以后慢慢积累补充"><a href="#以后慢慢积累补充" class="headerlink" title="以后慢慢积累补充"></a>以后慢慢积累补充</h2><ul>
<li><a href="./linux/home.html">Linux相关知识点</a></li>
<li><a href="./python/index.html">Python</a> 未完待续，后期慢慢补上<ul>
<li>学习来源github 共勉之！(<span class="exturl" data-url="aHR0cHM6Ly9naXRodWIuY29tL2phY2tmcnVlZC9QeXRob24tMTAwLURheXM=">https://github.com/jackfrued/Python-100-Days<i class="fa fa-external-link-alt"></i></span>)</li>
<li>微软出了一个《Develop With Python on Windows》<br>  (<span class="exturl" data-url="aHR0cHM6Ly9kb2NzLm1pY3Jvc29mdC5jb20vemgtY24vd2luZG93cy9weXRob24vZ2V0LXN0YXJ0ZWQvcHl0aG9uLWZvci1lZHVjYXRpb24=">https://docs.microsoft.com/zh-cn/windows/python/get-started/python-for-education<i class="fa fa-external-link-alt"></i></span>)</li>
</ul>
</li>
<li><a href="./vue/qa.html">Vue学习中</a></li>
<li>大数据学习</li>
</ul>
<h2 id="我的公众号"><a href="#我的公众号" class="headerlink" title="我的公众号"></a>我的公众号</h2><img src="/blogwebpage/images/wechatpublic.jpg" class="" title="我的公众号">


<h2 id="大神博客"><a href="#大神博客" class="headerlink" title="大神博客"></a>大神博客</h2><ul>
<li><span class="exturl" data-url="aHR0cHM6Ly9ibG9nLmliaXJlbWUuY29tLw==">https://blog.ibireme.com<i class="fa fa-external-link-alt"></i></span></li>
</ul>
<p><span class="exturl" data-url="aHR0cHM6Ly93d3cuamlhbnNodS5jb20vcC9lM2Q1MjFiMmNiNDM=">需要再解读文章及子文章<i class="fa fa-external-link-alt"></i></span></p>
          <!--noindex-->
            <div class="post-button">
              <a class="btn" href="/blogwebpage/home.html#more" rel="contents">
                阅读全文 &raquo;
              </a>
            </div>
          <!--/noindex-->
        
      
    </div>

    
    
    
      <footer class="post-footer">
        <div class="post-eof"></div>
      </footer>
  </article>
  
  
  

      
  
  
  <article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-CN">
    <link itemprop="mainEntityOfPage" href="https://wangkejie.gitee.io/blogwebpage/os/ios-macos.html">

    <span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
      <meta itemprop="image" content="/blogwebpage/images/avatar.gif">
      <meta itemprop="name" content="Jack Wang">
      <meta itemprop="description" content="书山有路勤为径，学海无涯苦作舟！">
    </span>

    <span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
      <meta itemprop="name" content="王科杰">
    </span>
      <header class="post-header">
        <h2 class="post-title" itemprop="name headline">
          
            <a href="/blogwebpage/os/ios-macos.html" class="post-title-link" itemprop="url">Mac、iOS操作系统</a>
        </h2>

        <div class="post-meta">
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-calendar"></i>
              </span>
              <span class="post-meta-item-text">发表于</span>

              <time title="创建时间：2019-12-27 00:00:00" itemprop="dateCreated datePublished" datetime="2019-12-27T00:00:00+08:00">2019-12-27</time>
            </span>
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-folder"></i>
              </span>
              <span class="post-meta-item-text">分类于</span>
                <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
                  <a href="/blogwebpage/categories/OS/" itemprop="url" rel="index"><span itemprop="name">OS</span></a>
                </span>
                  ，
                <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
                  <a href="/blogwebpage/categories/OS/macos-ios/" itemprop="url" rel="index"><span itemprop="name">macos-ios</span></a>
                </span>
            </span>

          

        </div>
      </header>

    
    
    
    <div class="post-body" itemprop="articleBody">

      
          <p>整体上还算不错，对内核，Mach和BSD的介绍，包括一些函数和调用等，以及对异常处理的描述，对于理解PLC这个崩溃日志生成的库还是很有帮助的。同时一些内核线程、用户线程的概念也算是填补部分知识空白。引导过程虽然讲的很详细，不过兴趣不大。</p>
<h1 id="名词解释"><a href="#名词解释" class="headerlink" title="名词解释"></a>名词解释</h1><p>ASLR：Address Space Layout Randomization 地址空间布局随机化</p>
<p>XNU：X is Not UNIX</p>
<p>POSIX：Portable Operating System Interface 可移植操作系统接口</p>
<p>XPC：高级IPC框架，实现进程间特权的分离</p>
<p>ELF：Executable and Library Format ，Unix下的可执行文件格式</p>
<p>__LINKEDIT：由dyld使用，这个区包含了字符串表、符号表以及其他数据</p>
<p>pthread：就是BSD层实现的POSIX规范的线程，Mach层则是mach_thread</p>
<p>DFU：设备固件更新模式，这个模式用于更新iOS镜像</p>
<p>HFS：Hierarchical File System 层次文件系统</p>
<p>FAT：File Allocation Table 文件分配表</p>
<p>NFS：Network File System网络文件系统</p>
<p>VFS：Virtual File System虚拟文件系统</p>
<p>LR寄存器：保存了当前函数的返回地址</p>
<p>PC寄存器：指令指针，程序计数器，PC寄存器中的内容，是下一条要取来执行的指令的地址</p>
<p>ABI：Application Binary Interface 应用程序二进制接口</p>
<h1 id="第一部分-第一到三章-高级用户指南"><a href="#第一部分-第一到三章-高级用户指南" class="headerlink" title="第一部分 第一到三章 高级用户指南"></a>第一部分 第一到三章 高级用户指南</h1><p>1.iOS系统的GUI是springboard，这是大家熟知的触屏应用加载器。</p>
<p>2.Darwin是操作系统的类UNIX核心，本身由内核，XNU和运行时组成。</p>
<p>3.XNU实际上是由两种技术混合在一起的：Mach和BSD，此外还添加了一些其他的组件，主要是IOKit。</p>
<p>4.在Mac OS中，“bundle”这个词实际上描述的是两种不同的术语：第一种是本节中讨论的目录结构；第二种是共享库目标的一种文件目标格式，共享库由进程显示的加载（普通的库是隐式加载的）。这个词有时候也表示一个插件。</p>
<p>5.OS X是在Mach内核的基础上构建的，而Mach是NeXTSTEP的遗产。BSD层是对Mach内核的包装，但是Mach系统调用仍然可以在用户态访问。</p>
<p>6.内核XNU是Darwin的核心，也是整个OS X的核心。XNU本身由以下几个组件构成：Mach微内核，BSD层，libKern，IOKit。</p>
<p>7.Mach微内核仅能处理操作系统最基本的职责：进程和线程抽象，虚拟内存管理，任务调度，进程间通信和消息传递机制。</p>
<p>8.BSD层建立在Mach层之上，BSD层提供了更高层次的抽象，其中包括：UNIX进程模型，POSIX线程模型（Pthread）及其相关的同步原语，UNIX用户和组，网络协议栈（BSD Socket API），文件系统访问，设备访问（通过/dev目录访问）。</p>
<p>9.OS X提供了一个系统级的通知机制。这是分布式IPC的一种形式，进程可以通过这种机制广播或监听事件。通知机制的核心部分在于notifyd(8) 守护程序，这个守护程序是在系统引导时启动的，这是Darwin的通知服务器。还有一个守护程序 distnoetd(8) 的作用是分布式通知服务器。notify(8) 默认使用Mach消息并注册Mach端口 com.apple.system.notification_center，能够处理大部分通知。notify(8)还有一个有意思的特点，这个API允许通过Mach消息传递文件描述符。</p>
<p>10.苹果通过代码签名，沙盒以及entitlement授权文件来保证iOS和OS X的安全。</p>
<p>11.沙盒机制也有一个专用的守护程序usr/libexec/sandboxd，这个程序运行在用户态，提供了跟踪功能以及内核扩展所需要的辅助服务，这个守护程序是根据需要启动的。</p>
<h1 id="第四章-进程线程和Mach-O"><a href="#第四章-进程线程和Mach-O" class="headerlink" title="第四章 进程线程和Mach-O"></a>第四章 进程线程和Mach-O</h1><p>1.尽管同一个可执行程序可以并发的启动多个实例，但是每一个实例都有一个不同的PID。</p>
<p>2.子进程返回的整数由其父进程收集。进程将要返回的值传递给exit(2) 系统调用（或者从main()函数返回）。</p>
<p>3.一个进程内的所有线程都共享虚拟内存空间，文件描述符和各种句柄。</p>
<p>4.进程的生命周期开始于SIDL状态，在这个状态中，进程仍被定义为”正在初始化“，不会响应任何信号，也不会进行任何操作。</p>
<p>5.睡眠的进程也会被信号唤醒。通过一个特殊的信号（TSTOP或TOSTOP）可以使一个进程停止执行。这相当于”冻结“了进程（即同时挂起这个进程的所有线程），将这个进程置于”深度睡眠“的状态。恢复这个进程的唯一方法就是发送另一个信号（CONT），这个信号可以将进程切换回可运行状态，使得进程中的每一个线程都可以被重新调度了。</p>
<p>6.终止一个进程会同时终止其所有线程。但是在进程完成终止之前，会短暂的处于僵尸（zombie）状态。每一个进程在安息之前都会有很短暂的时间处于这个状态。僵尸进程都是绝对死亡的进程，僵尸进程只是进程的空壳，所有的资源都被释放了，但是仍然占用着PID。</p>
<p>7.pid_suspend”冰冻“一个进程，pid_resume”解冻“一个进程。冰冻背后的挂起操作是在更为底层的Mach任务的层次实现的，而不是进程的层次实现的，所以这个睡眠更深。iOS的springboard大量使用了这些调用，比如用户按下Home键时。</p>
<p>8.iOS还添加了一个私有的系统调用 pid_shutdown_sockets，这在OS X是没有的。这个系统调用可以在进程之外关闭这个进程所有的套接字。只有springboard使用了这个调用，多半是挂起进程时使用的。</p>
<p>9.信号指发送给程序的异步通知，其中不包括数据（或只包括非常少量的数据）。信号是操作系统发送给进程的，用于表示发生了某种条件，而这种条件通常是因为某类硬件错误或程序异常而产生的。除了SIGKILL之外，进程可以通过一些系统调用屏蔽或处理以下的所有错误。</p>
<p>10.通用二进制（胖二进制）格式只不过是其支持的各种架构的二进制文件的打包文件。也就是说，这种格式的文件包含一个非常简单的文件头，文件头后面依次拷贝了每一种支持架构的二进制文件。lipo这个工具可以提取、删除或替换通用二进制文件中制定架构的二进制代码，因此可以用于对通用二进制文件进行”瘦身“。这个工具还可以显示胖二进制文件头的详细信息。</p>
<p>11.调用一个二进制文件时，Mach加载器会首先解析胖二进制文件头，确定其中可用的架构，然后只加载最适合的架构的代码，因此不相关架构的代码不会占用任何内存。</p>
<p>12.Mach-O格式具有一个固定的文件头，文件头一开始是一个魔数值，加载器可以通过这个魔数值快速判断这个二进制文件用于32位还是64位，在魔数值之后跟着的是CPU类型及子类型字段。</p>
<p>13.在iOS中，没有暴露sysct接口，堆和栈都默认不可执行。</p>
<p>14.Mach-O文件头的主要功能在于加载命令load command。otool工具可用于分析Mach-O文件。</p>
<p>15.加载过程在内核的部分负责新进程的基本设置——分配虚拟内存，创建主线程，以及处理任何可能的代码签名/加密的工作。然而对于动态链接的可执行文件（大部分可执行文件都是动态链接的）来说，真正的库加载和符号解析的工作都是通过LC_LOAD_DYLINKER命令指定的动态链接器在用户态完成的。控制权会转交给链接器。</p>
<p>16._PAGEZERO段（空指针陷阱）、_TEXT段（程序代码）、_DATA段（程序数据）和_LINKEDIT（链接器使用的符号和其他表）段提供了LC_SEGMENT命令。段有时候也可以进一步分解为区（section）。</p>
<p>17.当所有的库都完成加载之后，dyld的工作也完成了，之后由LC_UNIXTHREAD命令负责启动二进制程序的主线程（因此主线程总是在可执行文件中，而不会在其他二进制文件中例如库文件）。</p>
<p>18.LC_THREAD用于核心转储文件，Mach-O核心转储文件实际上是一组LC_SEGMENT命令的集合，这些命令负责建立起进程的内存镜像。</p>
<p>19.LC_MAIN命令的作用是设置程序主线程的入口点地址和栈大小。</p>
<p>20.Mach-O二进制文件有一个重要特性就是可以进行数字签名。LC_CODE_SIGNATURE包含了Mach-O二进制文件的代码签名，如果这个签名和代码本身不匹配（或者在iOS上这条命令不存在），那么内核会立即给进程发送一个SIGKILL信号，将进程杀死，没有商量的余地。</p>
<p>21.dyld是一个用户态的进程，dyld不属于内核的一部分，而是作为一个开源的项目由苹果单独维护的。</p>
<p>22.可执行文件很少是独立的，除了极少数的一些静态链接的可执行文件，大部分可执行文件都是动态链接的。</p>
<p>23.内核加载器执行的设置工作包括根据段的描述初始化进程地址空间以及执行其他命令。然而，仅有非常少量的进程只需要内核加载器就可以完成加载，而OS X上几乎所有的程序都是动态链接的。也就是说，Mach-O镜像中有很多”空洞“——即对外部的库和符号的引用——这些空洞要在程序启动时填补。这项工作就需要由动态链接器来完成。这个过程有时候也称为符号绑定（binding）。</p>
<p>24.动态链接器是内核执行LC_DYLINKER 加载命令时启动的。通常情况下，使用的是 /usr/lib/dyld 作为动态链接器，不过这条加载命令可以指定任何程序作为参数。链接器接管刚创建的进程的控制权，因为内核将进程的入口点设置为链接器的入口点。链接器索要完成的工作，就是查找进程中所有的符号和库的依赖关系，然后解决这些关系。这个过程必须递归的完成，因为通常情况下库还会依赖于其他的库。</p>
<p>25.通过otool -L命令可以显示库的依赖关系。</p>
<p>26.LC_LOAD_DYLIB命令告诉链接器在哪里可以找到这些符号。链接器要加载每一个指定的库，并且搜寻匹配的符号。被链接的库有一个符号表，符号表将符号名称和地址关联起来。符号表在Mach-O目标文件中的地址可以通过LC_SYMTAB加载命令指定的symoff找到。</p>
<p>27.libSystem库是系统上所有二进制代码的绝对先决条件，不论是C、C++还是Objective-C的程序。这是因为这个库是对底层系统调用和内核服务的接口，如果没有这些接口就什么事也干不了。</p>
<p>28.共享库缓存指的是一些库经过预先链接，然后保存在磁盘上的一个文件中。iOS中大部分常用的库都被缓存了。这个概念有点类似安卓的prelink-map，在prelink-map中的库被提前链接到地址空间中的固定偏移处。</p>
<p>29.为了节省加载的时间，iOS的dyld采用了一个共享库链接缓存，苹果从iOS3.0开始将所有的基础库都移到了这个缓存中。</p>
<p>30.在OS X中，dyld共享库缓存保存在/private/var/db/dyld目录下。在iOS中，共享库缓存可以在/System/Library/Caches/com.apple.dyld 中找到。这个缓存是一个单独的文件，即dyld_shared_cache_armv7。共享库缓存都会增长到非常庞大，OS X包含整整200多个文件，而iOS包含500多个文件，大小约为200M。</p>
<p>问题：共享库缓存到底是一个文件还是多个文件的组合？如果APP使用的第三方的动态库，是APP启动的时候操作系统才去加载，还是手机开机后自动加载这个共享库缓存目录下的文件？</p>
<p>31.OS X的dyld支持两级名称空间。这个特性是10.1引入的，指的是符号名称还包含其所在库的信息。这种方法更具有优势，因为允许两个不同的库导出相同的符号——而这在其他UNIX中会产生链接错误。有时候又需要禁用这种行为，通过将DYLD_FORCE_FLAT_NAMESPACE 环境变量设置为非零的值即可禁用。</p>
<p>32.函数拦截是传统ld没有而dyld有的特性。DYLD_INTERPOSE宏定义允许一个库将其库函数实现替换为另一个函数的实现。——这也是追踪函数调用和修改函数实现的原理</p>
<img src="/blogwebpage/images/system/dyld.png" class="" title="dyld">

<p>33.用户态的一个优点在于虚拟内存的隔离。进程独享一个私有的地址空间。</p>
<p>34.和所有标准的C语言程序一样，OS X中的可执行文件也有一个标准的入口点，默认名称为”main“。不过除了三个标准的参数——argc、argv和envp——之外，Mach-O程序还接受第四个参数：名为”apple“的char**。在Snow Leopard系统之前，”apple“参数只包含一个字符串——程序的完整路径，即启动这个程序所用的execve()系统调用传入的第一个参数。dyld在进程加载的过程中使用了这个参数。从Lion系统开始，”apple“参数被扩展为一个完整的向量，其中包括两个新加入的参数。</p>
<p>35.Cocoa应用程序的入口也是标准的C main()，不过常见做法是将main实现为NSApplicationMain()的包装，然后通过其进入Objective-C的编程模型。</p>
<p>36.重写内存最常用的方法是采用缓冲区溢出（即利用未经保护的内存复制操作越过栈上数组的边界），将函数的返回地址重写为自己的指针。不仅如此，黑客还有更具创意的技术，例如破坏pringtf()格式化字符串以及基于堆的缓冲区溢出等。</p>
<p>37.ASLR：进程每一次启动时，地址空间都会被简单的随机化——只是偏移，而不是搅乱。实现方法是通过内核将Mach-O的段平移某个随机系数。</p>
<p>38.在64位模式下，由于内存空间巨大，所以也就可以遵循其他操作系统采用的模型了，即将内核的地址空间映射到每一个进程的地址空间中。这是64位地址空间和传统的OS X模型的不同之处，传统的OS X内存模型中内核有自己的地址空间，但是新的地址空间允许更快速的用户态/内核态切换（共享CR3寄存器，CR3寄存器是包含了页表指针的控制寄存器）。</p>
<p>39.在内核层面，既没有用户堆也没有栈存在，所有的内存相关操作都要归约为页面。</p>
<p>40.尽管栈在传统上一直是用来保存自动变量的，但是在某些情况下，程序员也可以选择使用栈来动态分配内存，方法是使用鲜为人知的alloca()。如果发生了栈溢出，alloca()会返回NULL，进程会收到SIGSEGV信号。</p>
<p>41.iOS中VM压力释放机制依赖于Jetsam，Jetsam是一种类似于Linux的Out-Of-Memory killer的机制。</p>
<p>42.OS X有一个来自于Mach的独特之处在于，交换空间不是直接在内核层次管理的，而是由一个专用的用户进程dynamic_pager()处理所有的交换请求。这个进程在引导时由launchd通过一个属性列表文件cpm.apple.dynamic_pager.plist启动。</p>
<p>43.线程，作为最大化利用进程时间片的方法应运而生：通过使用多个线程，程序的执行可以分割为表面看上去并发执行的子任务。</p>
<p>44.进程中线程的抢占开销比多任务系统对进程抢占的开销要小。因此从这个角度看，大部分操作系统开始将调度策略从进程转换到线程是有意义的。</p>
<p>45.多处理器更是特别适合线程，因为多个处理器核心共享同样的cache和RAM——这为多线程之间的共享虚拟内存提供了基础。</p>
<p>46.GCD自己维护了一个底层的线程库实现，以支持并发和异步的执行模型，减轻开发者处理并发问题的负担，以及减少类似于死锁之类的潜在错误。GCD的另一个优势是能够自动的随着逻辑处理器的个数而扩展。 ——YYDispatchQueuePool可以根据设备的物理核心数量来创建对应的线程数量。</p>
<h1 id="第五章-进程跟踪和调试"><a href="#第五章-进程跟踪和调试" class="headerlink" title="第五章 进程跟踪和调试"></a>第五章 进程跟踪和调试</h1><p>1.OS X中的调试工具首先要介绍的就是 DTrace。DTrace是一个重要的调试平台，移植自Sun的Solaris。DTrace中的D指的是D语言，这是一门完整的跟踪语言，通过这个语言可以创建专用的跟踪器，或称为探测器。D语言脚本被编译后由内核执行。</p>
<p>2.iOS中根本就没有提供DTrace。Linux上的ptrace提供了完整的进程跟踪和调试能力，因此称为了Linux下strace，gdb的基础。</p>
<p>3.DTrace神器的调试功能来源于能在内核中执行探测器的能力。DTrace的用户态部分由/usr/lib/dtrace.dylib 负责，Instruments和脚本解释器/usr/sbin/dtrace都使用了这个库。这是编译D脚本的运行时系统。然而，对于大部分有用的脚本来说，实际的执行都在内核态。DTrace通过一个特殊的字符设备(/dev/device)和内核组件进行通信。</p>
<img src="/blogwebpage/images/system/DTrace.png" class="" title="DTrace">

<p>4.sysctl机制在之前的章节中已经讨论过了，sysctl提供 一些显示进程统计数据的变量。sysctl获得进程ID列表的机制非常重要（事实上，ps和top指令都是通过这个机制获得进程列表的）。</p>
<p>5.除了DTrace和Instruments之外，在OS X中海油一些工具可以获得系统或进程状态的快照：system_profiler，sysdiagnose，allmemory，stackshot，stack_snapshot系统调用。</p>
<p>6.allmemory工具的作用是捕获用户进程的所有内存使用情况。运行时，这个工具遍历系统中的每一个进程，然后将其内存映射导出至/tmp/allmemoryfiles（可以通过-o指定其他文件）。获得了所有进程内存快照之后，allmemory会显示每一个进程的汇总统计数据，还会显示框架的内存使用。</p>
<p>7.stack_snapshot这个系统调用可以捕获指定进程中所有线程的状态。</p>
<p>8.sc_usage工具显示每一个进程的系统调用信息。fs_usage可以显示系统调用，但是显示的是与文件、套接字和目录相关的应用，这个工具可以显示系统范围内的跟踪（除非调用时提供了PID或命令参数）。</p>
<p>9.latency工具显示中断和调度的延迟值。这个工具展示落在阈值内的上下文切换和中断处理程序计数，这两个阈值分别可以通过-st和-it参数设置。</p>
<p>10.XNU包含一个称谓kdebug的内建内核跟踪设施。kdebug利用内核缓冲器来记录日志，而内核缓冲器的空间极为有限。</p>
<p>11.在UNIX中，崩溃和一个信号有关。崩溃的真正原因来自于内核，内核发现进程无法继续执行时，生成这个信号作为最后的补救办法。</p>
<p>12.当一个进程崩溃时，可以选择是否生成核心存储文件。iOS和OS X都没有选择创建巨大的核心转存文件，而是包含了一个CrashReporter，当进程异常终止时自动触发Crash Reporter，生成详细的崩溃日志。这个机制在进程消亡之前进行快速简单的分析，并且在崩溃日志中记录重要的内容。</p>
<p>13.有没有可能在一个应用程序崩溃时自动运行另一个应用程序？在iOS和OS X中，将异常端口绑定至BSD进程底层的Mach任务的机制则能实现这一点。</p>
<p>14.spindump和sample命令的采样方法都是类似的——挂起进程，记录栈跟踪（spindump使用之前描述的stack_snapshot系统调用），然后恢复进程。采样间隔通常大约为10毫秒，整个采样过程通常持续10秒，这两个值是可以配置的。</p>
<p>15.应用程序崩溃的主要原因就是缓冲区溢出（既包含栈也包含堆）和堆内存的破坏。</p>
<img src="/blogwebpage/images/system/libcmalloc.png" class="" title="libcmalloc">

<p>16.libgmalloc.dylib这个库可以截获并调试内存分配，这个强大的库的工作原理是截获LibSystem中的分配函数。</p>
<p>17.任何读/写操作如果越过了缓冲区的尾部就会导致读写操作越过页边界，从而导致一个未处理的页错误，使得进程收到总线错误的信号（SIGBUS）而崩溃。</p>
<p>18.标准的UNIX命令ps可以显示进程列表。UNIX的top命令是一个获得当前系统运行状况的关键工具，在OS X和iOS上都可用，而且相比标准版本有所修改。这些修改都和底层的Mach架构有关，使得top既能显示UNIX的信息（来自XNU的BSD层），也能显示Mach的信息。</p>
<p>19.有时候需要查看某个进程在使用哪些文件，或某个文件正在被哪些进程使用。lsof()和fuser()这两个工具就分别能够实现以上两个功能。lsof()是对之前描述的fs_usage的补充，因为后者只能看到新打开文件的操作，而看不到已经打开的文件。lsof()能显示一个进程所有文件描述符（包括套接字）的映射。换句话说，fs_usage可以持续运行，lsof产生的是一个快照。</p>
<p>20.fuser()提供的是反向的映射——从文件到拥有这个文件的进程。这个工具的主要作用是诊断文件锁定或者“文件被占用”的问题。</p>
<p>21.尽管XNU在用户态提供了完整的POSIX API，展示了UNIX兼容的人格，但是底层的实现却主要依靠Mach的基本原语。</p>
<img src="/blogwebpage/images/system/infocommand.jpg" class="" title="infocommand">


<p>22.随着苹果转向LLVM-gcc转换，还引入了LLDB作为GDB的替代品。LLDB的语法基本上和GDB类似，但是调试功能大有增强。</p>
<h1 id="第六章-引导过程-第七章-贯穿始终——launchd"><a href="#第六章-引导过程-第七章-贯穿始终——launchd" class="headerlink" title="第六章 引导过程 第七章 贯穿始终——launchd"></a>第六章 引导过程 第七章 贯穿始终——launchd</h1><p>1.固件（firmware）可以看作是一种软件，这种软件因为被写入了芯片，所以是“固化”的。固件代码本身可以保存在只读存储器（ROM）中，也可以保存在电可擦除只读存储器EEPROM中</p>
<p>2.BIOS是一个固定的程序，而且通常都是封闭的。EFI是一套接口。EFI更像是一个运行时环境，规范了一组应用程序编程接口，基于EFI的程序可以利用这些接口实现功能。</p>
<p>3.苹果的EFI实现的另一个重要特性是Boot Camp。Boot Camp是苹果双重引导的解决方案，这个解决方案再Mac硬件上运行非苹果的操作系统（主要是Windows）。</p>
<img src="/blogwebpage/images/system/launchd.jpg" class="" title="launchd">


<p>4.一旦苹果关闭了某个iOS版本的时间窗口，将安全服务器配置为拒绝这个版本的签名时，就不可能降级固件了。</p>
<p>5.OS X和iOS中，用户环境始于launchd。launchd作为系统中的第一个用户态进程，负责直接或间接的启动系统中的其他进程。launchd仍然属于Darwin的范畴。</p>
<p>6.launchd是由内核直接启动的。负责加载BSD子系统的主内核线程创建一个线程来执行bdsinit_task。这个线程获得PID 1，并且临时命令为“init”，这是一项来源于BSD的遗产。bsdinit_task然后调用load_init_program()，这个函数调用execve()系统调用（在内核空间中执行）执行守护程序。</p>
<p>7.系统范围的launchd（PID 1）是不可能终止的。事实上，这个launchd是系统上唯一不朽的进程。当系统关闭的时候，launchd也是最后一个退出的进程。</p>
<p>8.launchd的核心职责是根据预定的安排或实际的需要加载其他应用程序或作业。launchd区分两种类型的后台作业：</p>
<p>①守护程序（daemon）和传统的UNIX概念一样，是后台服务，通常和用户没有交互。守护程序由系统自动启动，不考虑是否有用户登录进系统。</p>
<p>②代码程序（agent）是一类特殊的守护程序，只有在用户登录的时候才启动。和守护程序的不同之处在于，代理程序可以和用户交互，有的代理程序还有GUI。</p>
<p>③iOS不支持用户登录的概念，因此只有LaunchDaemon。</p>
<p>④守护程序和代理程序都是通过自己的属性列表文件（.plist）声明的。</p>
<p>9.launchd是用户态出现的第一个进程。当系统还在启动初期的时候，launchd是系统上唯一的进程（尽管这个状态很短暂）。这意味着系统启动和功能的方方面面都和launchd直接或间接相关。</p>
<p>10.launchd的第一个，也是主要的职责就是init守护程序的职责。init的职责是派生出各种各样的后台守护程序，设置好系统，然后转入后台，确保这些守护程序都活着。如果有程序死亡了，launchd要负责重新派生出新的守护程序。</p>
<p>11.传统意义上，init是用户态的第一个进程，从init fork出其他进程（转而可能fork出更多进程），init设置的资源限制会被所有后代继承。而launchd（新时代意义上的用户态第一个进程）还会设置Mach异常端口，内核内部通过异常端口处理异常情况并生成信号。</p>
<p>12.UNIX传统上包含两个守护程序——atd和crond——来定时作业，即在指定时间运行指定的命令。第一个守护程序atd负责一次运行的作业，第二个守护程序crond提供了重复执行作业的支持。</p>
<p>13.inetd/xinetd的用途是启动网络服务。这个守护程序的职责是绑定一些端口（UDP端口或TCP端口），当有连接请求到达的时候，根据需要启动相应的服务程序，并且将服务程序的输入输出描述符（stdin，stderr，stdout）连接到对应的套接字。</p>
<p>14.Mach的IPC服务依赖于“端口”的概念（有点类似TCP和UDP端口的概念），端口是通信的端点。</p>
<p>15.launchd还整合了iOS的Jetsam机制，Jetsam机制可以强制施行虚拟内存使用率的限制，这项特性在没有交换空间的iOS中特别重要。</p>
<p>16.ReportCrash守护程序是默认的崩溃处理程序，截获所有应用程序的崩溃。通过设置作业的Mach异常端口，在发生崩溃的时候自动运行。</p>
<p>17.iOS中amfid守护程序，可以阻止一切无签名无entitlement的代码在iOS中运行。</p>
<p>18.apsd（ApplePushService.framework）守护程序则是苹果推送服务的守护程序，以mobile用户运行。</p>
<p>19.atc守护程序则用于空中流量限制。crash_mover守护程序用于将崩溃日志移动到 /var/Mobile/Library/Logs 目录。</p>
<p>20.mobile_obliterator守护程序则用于远程擦除设备。</p>
<p>21.lockdownd就像是用户态的狱警，是所有越狱者的头号敌人。lockdownd由launchd启动，负责处理设备激活、备份、崩溃报告、设备同步以及其他服务。</p>
<p>22.OS X下的图形shell环境是Finder，iOS使用的择时SpringBoard。</p>
<p>23.和Finder不太一样，SpringBoard几乎全部靠自己完成所有的工作，在CoreServices目录下也只有少量几个可加载的bundle。</p>
<p>lockbundle提供了锁屏时的功能。NowPlayingArtLockScreen.lockbundle负责提供当音乐播放器正在运行且屏幕锁定的时候的锁屏画面，PictureFramePlugin负责显示用户照片库中的图片。iPhone还有一个名为VoiceMemosLockScreen的bundle，负责显示语音信息和未接电话指示器。</p>
<p>24.SpringBoard是一个多线程的应用程序，线程数远多于Finder。如果SpringBoard超过几分钟没有响应，那么看门狗会重启系统。</p>
<p>25.SpringBoard注册的端口中，最重要的是PurpleSystemEventPort，这个端口通过GSEvent消息的方式处理UI事件。SpringBoard中的主线程调用GSEventRun()，GSEventRun()是一个处理UI消息的CFRunloop。其他线程都类似的运行循环，处理SpringBoard中的其他Mach端口。</p>
<p>26.XPC是Lion和iOS5新引入的轻量级进程间通信原语。libxpc.dylib提供了各种各样的C语言层次的XPC原语。默认情况下XPC的消息是异步发送的，应答也是异步的，通过reply_sync函数可以阻塞知道收到应答消息。XPC是通过Mach消息机制实现的。</p>
<h1 id="第二部分-内核"><a href="#第二部分-内核" class="headerlink" title="第二部分 内核"></a>第二部分 内核</h1><ul>
<li>第八章 内核架构</li>
</ul>
<p>1.内核既是一个操作系统，也是一个调度器，还是一个仲裁器，内核同时也提供安全服务。</p>
<p>2.内核从架构上分为巨内核，微内核和混合内核。</p>
<p>3.巨内核采取的方式是将所有的内核功能——不论是基础功能还是高级功能——全部放在一个地址空间中。在这种架构的内核中，线程调度和内存管理，以及文件系统、安全管理、甚至设备驱动全都在一起。</p>
<p>所有的内核功能都实现在同一个地址空间中吗。为了进一步优化，巨内核不进将所有的工呢过都组织在同一个地址空间中们还将这个地址空间映射到每一个进程的内存中。</p>
<p>在巨内核架构中，从用户态到内核态的切换非常搞笑，基本上就是一次线程切换的开销。这是因为内核的你内存页面映射在所有进程的地址空间中，也就是说，除了硬件强制的内核态和用户态之间的隔离外，两者之间其实没有任何分别。所有的进程，不论所有者或功能，都包含一份内核内存的拷贝，就好像包含共享库的拷贝一样。此外，这些拷贝（同样类似于共享库）都映射到了同一组物理页面，而且是常驻内存的物理页面。</p>
<p>4.XNU的核心组件Mach是一个微内核系统。</p>
<p>一个微内核值包含最核心的内核功能，代码量也最精简。内黑只负责完成最最关键的部分——通常包括任务调度和内存管理，其他的功能都交给外部服务程序（通常是用户态）完成。</p>
<p>微内核有几个巨内核没有的有点：正确性，稳定性和健壮性，灵活性（移植）。</p>
<p>尽管微内核架构有着种种优势，但是却有一个致命的缺点——性能。微内核的消息传递在底层需要通过内存复制操作以及数次上下文的切换来实现，而这些操作对计算速度的影响都不小。</p>
<p>5.混合内核试图结合两种内核的好处。内核最核心部分支持底层服务，包括调度、进程间通信和虚拟内存，是自包含的，这一部分就像微内核一样。所有其他的服务都实现在这个核心之外，但是也在内核态中，而且和这个核心在同一个内存空间中。</p>
<p>这种内核不强制要求消息传递。其他组件可以调用这个“内部核心”的服务，但是这个“内部核心”不能调用外部的组件。</p>
<p>6.从技术上说，XNU是一个混合内核。Windows内核也被认为是一个混合型的内核，但是两者差别巨大。Windows更接近巨内核，所以死亡蓝屏概率高，而XNU更接近于微内核。</p>
<p>7.XNU的Mach最早是一个真正的微内核，现在Mach的原语仍然是围绕着消息传递的基础构建的。然而，消息通常是以指针的形式传递的，因此没有昂贵的复制操作。这是因为大部分服务现在都在同一个地址空间中执行（因为也会被归为巨内核）。类似的，建立在Mach之上的BSD层一直都是一个巨内核，而且这个子系统也在同一个地址空间中。</p>
<p>8.32位的OS X应用程序可以享用完整的没有内核预留的地址空间——内核有自己的地址空间。然而在64位的OS X中，苹果却顺从了，就像其他巨内核的系统一样，内核空间和用户空间是共享的。在iOS中也是如此。</p>
<p>9.内核是一个受信任的系统组件。内核的功能和应用程序的功能之间需要有一种严格的分离，否则应用程序的崩溃会使整个系统本科鬼。这种分离需要由硬件强制支持，因为基于软件的强制实施不但会产生很大的开销，也不可靠。区分内核态和用户态非常重要，因此这个功能是由硬件提供的。</p>
<p>10.用户态和内核态的切换有两种类型：</p>
<p>①自愿转换，比如系统调用；</p>
<p>②非自愿转换，当发生异常、中断或处理器陷阱的时候，代码的执行会被挂起，并且保留发生错误时候的完整状态。控制权被转交给预定义的内核态错误处理程序或中断服务程序。</p>
<p>11.一共有三种类型的异常：</p>
<p>①错误（fault）：指令遇到一个可以纠正的异常，并且处理器可以重新启动这条出现异常的指令。</p>
<p>②陷阱（trap）：类似于错误，但是错误处理完成后返回发生陷阱指令之后的那条指令。</p>
<p>③中止（abort）：不可重启指令。</p>
<p>12.BSD系统调用，可以通过current_task获得当前BSD进程的数据结构。</p>
<h1 id="第九章-内核引导和内核崩溃"><a href="#第九章-内核引导和内核崩溃" class="headerlink" title="第九章 内核引导和内核崩溃"></a>第九章 内核引导和内核崩溃</h1><p>1.苹果只开源了针对OS X编译的XNU版本，iOS的版本则是闭源的。</p>
<p>2.和Linux内核类似，Linux可以针对特定架构编译，Mach也能。</p>
<p>3.如果要在一堆源码文件中查找某个特定的函数名、变量名或其他符号，grep是一个不错的工具，grep可以接受任何正则表达式，并且在.h和.c文件中寻找匹配。</p>
<p>4.vstart是i386/x64架构下的“官方”的内核初始化函数，标志着从汇编代码到C语言代码的转换。</p>
<p>5.除了虚拟内存之外，kernel_bootstrap还初始化Mach的一些关键抽象：</p>
<p>IPC——进程间通信是Mach构建的根基，IPC要求一些重要的资源，例如内存、同步对象和Mach接口生成器；</p>
<p>时钟clock——通过时钟抽象实现闹铃；</p>
<p>账本——账本是Mach系统的记账工具；</p>
<p>任务task——任务是Mach的容器，类似BSD的进程；</p>
<p>线程thread——线程是实际的执行单元。任务只不过是一个资源容器，真正被调度和执行的是线程。</p>
<p>6.关于异常处理</p>
<img src="/blogwebpage/images/system/exception.png" class="" title="异常处理">


<h1 id="第十章-Mach原语：一切以消息为媒介"><a href="#第十章-Mach原语：一切以消息为媒介" class="headerlink" title="第十章 Mach原语：一切以消息为媒介"></a>第十章 Mach原语：一切以消息为媒介</h1><p>1.XNU的核心是苹果从NeXTSTEP带来的Mach微内核。尽管Mach核心被BSD层包装起来了，而且主要的内核接口是标准的POSIX系统调用，但是这个Mach核心具有一组独特的API和原语。</p>
<p>消息传递原语：讨论消息和端口，这是Mach IPC的基础。</p>
<p>同步原语：锁和信号量是两种内核对象，这些对象用于确保并发执行的安全。</p>
<p>2.Mach采用的是极简主义的概念。Mach和其他操作系统不同，其他操作系统提供了用户态进程实现所基于的完整模型，而Mach只提供了一个极简的模型，操作系统本身可以在这个模型的基础上实现。</p>
<p>在Mach中，所有的东西都是通过自己的对象实现的。进程（在Mach中称为任务）、线程和虚拟内存都是对象，所有对象都有自己的属性。</p>
<p>Mach的独特之处在于选择了通过消息传递的方式实现对象和对象之间的通信。Mach对象不能直接调用另一个对象，而是必须传递消息。源对象发送一条消息，然后这条消息被加入到目标对象的队列中等待处理。类似的，消息处理中可能会产生一个应答，这个应答通过另一条消息被发送回源对象。消息是以FIFO的方式可靠传输的（如果消息被发送出去，那么一定能被收到）。</p>
<p>3.Mach的首要设计目标也是最重要的目标就是要将所有功能移出内核，并且放在用户态中，将内核保持在极简的状态。</p>
<p>4.Mach的设计有一个非常强大的优点——在设计中考虑了多处理。从理论上说，Mach可以轻松扩展成计算机集群使用的操作系统。</p>
<p>5.Mach中最基本的概念是消息，消息在两个端点或端口之间传递。任何两个端口之间都可以传递消息——不论是同一台机器上的端口还是远程主机的端口。Mach消息的设计考虑了参数串行化、对齐、填充和字节顺序的问题，这些问题都被消息实现隐藏了。</p>
<p>6.Mach消息的发送和接收都是通过同一个API函数mach_msg()进行的，这个函数在用户态和内核态都有实现。</p>
<p>7.Mach消息原本是为真正的微内核架构而设计的，也就是说，mach_msg()函数必须在发送者和接受者之间复制消息所在的内存。但是XNU通过单一内核的方式来“作弊”：所有的内核组件都共享同一个地址空间，因此消息传递时只需要传递消息的指针就可以了，从而省去了昂贵的内存复制操作。</p>
<p>8.为了实现消息的发送和接收，mach_msg()函数调用了一个Mach陷阱（trap）。Mach陷阱就是Mach中跟系统调用等同的概念，在用户态调用mach_msg_trap()会引发陷阱机制，切换到内核态，在内核态中，内核实现的mach_msg()会完成实际的工作。</p>
<p>9.消息在端口之间传递。消息从某个端口发送到另一个端口。每个端口都可以接收来自任意发送者的消息，但是只能有一个指定接收者。向一个端口发送消息时实际上是将消息放在一个队列中，直到消息能被接收者处理。</p>
<p>10.所有的Mach原生对象都是通过对对应的端口访问的。</p>
<p>11.端口和权限也可以从一个实体传递到另一个实体。实际上，通过复杂消息将端口从一个任务传递到另一个任务并不罕见。这是IPC设计中的一个非常强大的特性，有一点类似于主流UNIX的domain socket，允许在进程之间传递文件描述符。</p>
<p>12.Mach的消息传递模型是远程过程调用（RPC）的一种实现。</p>
<p>13.IPC所需要的基本原语：消息、发送和接收消息的端口，以及确保安全并发的信号量和锁。</p>
<p>14.每一个Mach任务（Mach任务是一个对应于进程的高层次抽象）包含一个指针指向自己的IPC名称空间，在名称空间中保存了自己的端口。此外，任务也可以获得系统范围内的端口。</p>
<p>15.同步机制的根本是排他访问的能力：当别人在使用一个资源时，排除其他人对这个资源的访问。因此最基本的同步原语是互斥对象，也称为互斥体。互斥体只不过是内核内存中的普通变量，通常是机器字大小的证书，但是有一个特殊要求——硬件必须对这些变量进行原子操作。“原子”的意思就是说，对互斥体的操作决不允许被打断——即使是硬件中断也不能打断。在SMP系统上，对物理互斥还有一个要求，就是要求硬件实现某种内存屏障。</p>
<p>16.Mach的锁依赖两个层次组合而成：硬件相关层——依赖于硬件的特殊性质，并且通过特定的汇编指令实现原子性和互斥性；硬件无关层——通过统一的API包装硬件特定的调用，这些API使得Mach之上的层完全不用关心实现的细节。</p>
<p>17.互斥体有一个最大的缺点，就是一次只能有一个线程持有锁。读写锁就是这个问题的解决方案，读写锁能够区分读访问和写访问，多个读者可以同时持有锁，而一次只能有一个写者。当一个写者持有锁时，所有其他线程都被阻塞。 ——pthread_rwlock_t就是POSIX层的API在iOS下的读写锁，区分pthread_rwlock_rdlock读和pthread_rwlock_wrlock写的加锁，解锁统一用pthread_rwlock_unlock。</p>
<p>18.阻塞一个线程意味着放弃线程的时间片，把处理器让给调度器认为下一个要执行的线程。当锁可用时，调度器会得到通知，然后根据自己的判断将线程从等待队列中取出并重新调度。</p>
<p>19.Mach提供了信号量，信号量是泛化的互斥体。互斥体的值只能是0和1，而信号量的取值可以达到某个正数，即允许并发持有信号量的持有者的个数。信号量可以在用户态使用，而互斥体只能在内核态使用。</p>
<p>20.在XNU上，POSIX信号量的底层实现是通过Mach信号量实现的。</p>
<p>21.信号量可以转换为端口，也可以由端口转换而来。</p>
<p>22.锁集就是锁的数组，通过给定的锁ID可以访问锁。锁也可以传递给其他线程。交出一个锁会阻塞交出锁的线程，并唤醒接受锁的线程。</p>
<p>23.锁集的有趣之处在于允许锁的传递。锁的传递指的是将锁从一个任务传递给另一个任务的过程。Mach在调度中也使用了传递的概念，允许一个线程放弃处理器但是指定哪一个线程接替运行。</p>
<p>24.Mach提供了一组异常丰富的API调用用于查询机器信息，所有这些调用都要求获得主机端口才能工作。</p>
<p>主机API最重要的一个方面就是能提供其他方式几乎无法获得的信息。Mach API是获得内核模块信息，内存映射表信息以及其他POSIX（BSD层）无法获得的信息的最直接方法。</p>
<p>25.所有的用户都可以通过mach_host_self()获得主机端口，但是只有特权用户才能通过调用host_get_host_priv_port()获得特权端口。</p>
<p>26.host_set_exception_ports()获得/设置或交换主机层次的异常处理程序。</p>
<p>27.一个或多个processor_t对象可以分组为处理器集，或称为pset。pset中的处理器通过两个队列进行维护：一个是active_queue，保存当前正在执行线程的处理器；另一个是idle_queue，用于保存当前空闲的处理器。</p>
<h1 id="第十一章-Mach调度"><a href="#第十一章-Mach调度" class="headerlink" title="第十一章 Mach调度"></a>第十一章 Mach调度</h1><p>1.和所有现代的操作系统一样，内核调度的对象是线程，而不是进程。Mach使用了比进程更轻量级的概念：任务task。</p>
<p>2.线程定义了Mach中最小的执行单元。一个或多个线程包含在一个任务中。</p>
<p>3.Mach将任务定义为线程的容器，因此资源是在任务这个层次处理的。线程只能（通过端口）访问包含这个线程的任务中分配的资源和内存。</p>
<p>4.任务task是一种容器对象，虚拟内存空间和其他资源都是通过这个容器对象管理的。这些资源包括设备和其他句柄。资源进一步被抽象为端口。因此资源的共享实际上相当于允许对对应端口进行访问。</p>
<p>5.严格的说，Mach的任务并不是其他操作系统中所谓的进程，因为Mach作为一个微内核的操作系统，并没有提供“进程”的逻辑，而只提供了最基本的实现。不过在BSD的模型中，这两个概念有1：1的简单映射，每一个BSD进程（也就是OS X进程）都在底层关联了一个Mach任务对象。实现这种映射的防范是指定一个透明的指针bsd_info，Mach对bsd_info完全无知。</p>
<p>6.任务是没有生命的，任务存在的目的就是要成为一个或多个线程的容器。大部分针对任务的操作实际上就是遍历给定任务中的所有线程，并对这些线程进行对应的线程操作。</p>
<p>7.在任何时刻，内核都必须能够蝴蝶当前任务和当前线程的句柄。内核分别通过current_task()和current_thread()函数完成这两个任务。</p>
<p>8.thread_suspend/thread_resume表示挂起/恢复线程，会递增/递减挂起计数器。线程只有在其suspend计数器和所在的任务的suspend计数器都为0时才能执行。</p>
<p>9.当调用pthread_create()时，底层会转而调用Mach的API调用thread_create()，并且使用mach_task_self()作为第一个参数。</p>
<p>10.由于每一个处理器核心在同一时刻只能运行一个线程，所以内核必须具有抢占一个线程的执行，将处理器让给另一个线程的能力，从而实现上下文切换。</p>
<p>11.由于Mach具有处理器集的抽象，所以从某种角度说，Mach比Linux和Windows更擅长管理多核处理器：Mach可以将同一个CPU的多个核心放在同一个pset中管理，并且通过不同的pset管理不同的CPU。</p>
<p>12.上下文切换是暂停某个线程的执行，并且将其寄存器状态记录在某个预定义的内存位置中。当一个线程被抢占时，CPU寄存器中会加载另一个线程保存的线程状态，从而恢复那个线程的执行。</p>
<p>13.一个线程在CPU上可以执行任意长时间。执行指的是这样一个事实：CPU寄存器中填满了线程的状态，因此CPU执行该线程函数的代码。这个执行过程一直持续，直到①线程终止；②线程自愿放弃CPU；③外部中断打断了线程执行（时间片用完或更高优先级的线程被唤醒）。</p>
<p>14.每一个操作系统都提供了一个优先级的范围：Windows有32个优先级，Linux有140个优先级，而Mach有128个优先级。</p>
<p>内核线程的最低优先级为80，比用户态线程的优先级要高，可以保证内核以及系统维护管理的线程能够抢占用户态的线程。</p>
<p>通过 ps -l 命令可以查看优先级</p>
<p>15.Mach会针对每一个线程的CPU利用率和整体系统负载动态吊证每一个线程的优先级。因此线程会在自己的优先级范围中“漂移”，如果耗CPU太多则降低优先级，如果不能得到足够的CPU资源则提升优先级。</p>
<p>16.在使用多核、SMP或超线程的现代架构中，还可以设置某个线程和一个或多个指定CPU的亲缘性。这种亲缘性对于线程和系统来说都是有好处的，因为当线程回到同一个CPU上执行时，线程的数据可能还留在CPU的缓存中，从而提升性能。用Mach的说法，线程对CPU的亲缘性的意思就是绑定。</p>
<p>17.Mach含有的特殊特性：</p>
<p>①控制权转交（handoff）允许一个线程主动放弃CPU，但不是将CPU放弃给任何其他线程，而是降CPU转交给自己选择的某个特定的线程。</p>
<p>②使用续体可以使线程不用管理自己的栈，线程可以丢弃自己的栈，系统恢复线程执行时不需要恢复线程的栈。</p>
<p>③异步软件陷阱AST是软件对底层硬件陷阱机制的补充完善。通过使用AST，内核可以响应需要得到关注的带外（out-of-band）事件，例如调度事件。</p>
<p>18.Mach对yield做了改进，允许选择将CPU转交给谁。控制权转交并不是对调度器的强制要求，调度器还可以选择将控制权转交给其他线程（例如，如果指定的线程处于不可运行的状态）。作为控制权转交的结果，当前线程剩下的时间片也会被转交给新调度的线程。</p>
<p>19.如果线程要进行控制权转交而不是简单的yield操作，那么需要调用thread_switch()，Mach将thread_switch()导出为一个陷阱，因此也可以从用户态调用这个函数。</p>
<p>20.上下文切换采用的是每一个线程都有自己独有栈的模型，当线程自愿请求一次上下文切换时可以选择指定一个续体。如果指定了续体，那么当线程恢复执行时，系统会以续体作为入口点重新加载线程，并创建新的栈，之前的状态都不会得到保留。这样可以明显加快上下文切换的速度，因为不需要保存和加载寄存器（此外还能显著地节省内核栈的空间，内核栈本身很小，只有4个页面，即16kb）。续体中的线程只需要4-5kb的空间来保存线程状态，将16kb中的其他空间节省下来用作其他用途。使用续体不需要保存完整的寄存器状态和线程栈，只需要保存续体以及参数。</p>
<p>21.续体是缓解上下文切换开销的简单有效的机制，主要由Mach的内核线程使用。内核线程特别喜欢使用续体，Mach的内核线程是通过续体启动的。</p>
<p>22.Mach支持两种不同模式的抢占——显示抢占和隐式抢占，续体模式只能用于显示抢占。</p>
<p>23.系统中的线程可能会被两种方式抢占：一种是显示的抢占，即线程放弃CPU的控制权或进入阻塞的操作；另一种是隐式的抢占，这种抢占是由中断引起的。显示抢占有时候也被认为是同步的，因为这种抢占是事先可以预知的。而由于中断不可预测的本质，所以隐式的抢占是异步的。</p>
<p>24.发生显示抢占的原因可能是等待某个资源，等待某个IO，或睡眠一定的时间。当用户态的线程调用阻塞的系统调用（例如read(),select()和sleep()）时会发生显示抢占。</p>
<p>25.thread_invoke()函数负责执行上下文切换并负责处理续体。</p>
<p>26.显示抢占本身是有局限性的，将放弃CPU的选择权交给运行的线程是极为不可靠的。线程会陷入费时的处理操作中，甚至会进入死循环。</p>
<p>27.Mac OS X是一个抢占式的多任务系统。简单的说，Mach具有随时抢占一个线程的权利，不论这个线程是否准备好了抢占。和显示的抢占不同，这种隐式的抢占对于线程来说是不可见的。线程可以对这种抢占完全不知情，线程的状态会被透明的保存并恢复。大部分线程不会受到太大的影响，因为大部分线程都是IO密集型的。但是对于CPU密集型的线程来说，这种抢占可能会造成一些问题，特别是要求时间关键的性能时（例如视频和音频解码都是这种类型的任务）。</p>
<p>28.Mach是一个分时系统，而不是一个实时系统。</p>
<p>29.THREAD_AFFINITY_POLICY策略定义了线程的L2缓存亲缘性，这些线程共享同一块缓存。这意味着这些线程很可能运行在同一个CPU上，不论这个CPU有多少核心（毕竟同一个CPU上所有核心都共享同一块L2缓存）。</p>
<p>30.异步软件陷阱AST就是为了支持隐士抢占的。AST是人工引发的非硬件触发的陷阱。AST是内核操作的关键部分，而且是调度时间的底层机制，也是BSD信号的实现基础。</p>
<p>31.ast_taken函数（内核陷阱中和内核线程终止时也可以调用）负责处理除了内核idle线程之外的所有线程的AST。否则，这个函数会检查AST_BSD，这原本是对Mach的一个临时修改，使其能够处理BSD事件（例如信号），但是被永久的保留了。如果设置了AST_BSD，则调用bsd_ast处理信号。</p>
<p>32.Mach的线程调度算法高度可扩展，而且允许更换用于线程调度的算法。不过通常情况下，只启用了一个调度器，即传统调度器。调度器大量使用了AST机制。</p>
<p>33.对于要提供抢占式多任务的系统来说，必须有某种机制允许调度器能够首先得到CPU的控制权，从而抢占当前正在执行的线程，然后才能执行调度算法，并且通过调度算法决定当前的线程可以继续恢复执行还是要抢夺其CPU给更重要的线程使用。</p>
<p>34.为了能够从当前运行的线程抢夺CPU，现在的操作系统都利用了现有的硬件中断机制。由于中断的特点是强迫CPU在发生中断时“放下手中所有的任务”，并longjmp跳转到中断处理程序（也称为中断服务例程ISR）执行，因此可以通过中断机制在发生中断时运行调度器。但是问题是，中断是异步的。</p>
<p>35.内核可以配置时钟使其在给定数目的周期之后产生一个中断。这个中断源通常称为定时器中断。</p>
<p>36.解决方案是采用另一种不同的模型：无tick内核。在这种模型中，每一次定时中断发生时，定时器都会被重新设置为调度器认为需要下一次中断的时刻。这意味着在每一次定时器中断时，中断处理程序都要（非常快）扫描还没超期的截止时间线的列表。相比大量不必要的中断，每一次定时器中断中多做的这些处理工作还是值得的，而且通过只跟踪那些最紧急的截止时间线可以将这些处理工作的开销降到最低。</p>
<p>37.在添加非严格的定时器事件是会加上一个所谓的“宽限slop”值，通过宽限值可以合并一些定时器事件，从而增加这些定时器事件同时超时的概率（从而减少了定时器中断的总数）。</p>
<p>38.Mach只提供了一个异常处理机制用于处理所有类型的异常——包括用户定义的异常、平台无关的异常、以及平台特定的异常。</p>
<p>39.在Mach中，异常是通过内核中的基础设施——消息传递机制——处理的。异常由出错的线程或任务（通过msg_send()）抛出，然后由一个处理程序（通过msg_recv()）捕捉。处理程序可以处理异常，也可以清除异常，可以决定终止线程。</p>
<p>40.Mach的异常处理程序在不同的上下文中运行异常处理程序，出错的线程向预先指定好的异常端口发送消息，然后等待应答。每一个任务都可以注册一个异常端口，这个异常端口会对同一个任务中的所有线程起效。单个的线程还可以通过 thread_set_exception_prots 注册自己的异常端口。通常情况下，任务和线程的异常端口都是NULL，也就是说异常不会被处理。</p>
<p>41.发生异常时，首先尝试将异常抛给线程的异常端口，然后尝试抛给任务的异常端口，最后再抛给主机的异常端口（即主机注册的默认端口）。如果没有一个端口返回 KERN_SUCCESS，那么整个任务被终止。Mach不提供异常处理逻辑——只提供传递异常通知的框架。</p>
<p>42.exception_triage()负责主要的异常处理逻辑，这个逻辑在两种架构上的Mach消息层面都是一样的。这个函数尝试根据前文描述的方式——线程、任务、最终到达主机——利用exception_deliver()投递异常。</p>
<p>43.每一个线程或任务对象，以及主机本身，都有一个异常端口数组，这个数组中的端口通常初始化为IP_NULL。通过xxx_set_exception_ports()调用可以设置这些异常端口，其中的xxx为thread、task或host。</p>
<p>44.[mach]_exception_raise 用于EXCEPTION_DEFAULT，[mach]_exception_state_raise 用于EXCEPTION_STATE。[PLCrashReporter里有相关的使用] 这些函数最终通过调用ux_exception将异常转换为响应的UNIX信号，并且通过threadsignal将信号投递到出错的线程。</p>
<p>45.OS X的最重要的特性之一崩溃报告器（crash reporter）就是利用异常端口的机制实现的。launchd注册了异常端口，然后将所有子进程都应用同样的异常端口，因为异常端口是随着进程fork集成的。launchd将ReportCrash设置为MachExceptionHandler。通过这种方式，当一个launchd作业发生异常时，崩溃报告器会自动根据需要启动。调试器也可以利用异常端口捕捉异常并且在发生错误时中断。</p>
<p>46.Mach异常处理会先于UNIX异常处理发生。</p>
<p>47.使用mach_msg在异常端口上创建一个活动监视者。异常处理可以由同一个程序中的另一个线程来完成，不过更有意思的做法是在另一个程序中实现异常处理的部分。</p>
<p>48.Mach是XNU的微内核核心。XNU暴露给用户的主要接口：BSD层。BSD层使用了Mach作为底层的原语和抽象，向应用程序暴露出流行的POSIX API，使得OS X能够和很多其他的UNIX实现兼容。</p>
<p>常见的架构无关的Mach异常</p>
<p>EXC_BAD_ACCESS 内存访问异常，代码包含发生内存访问异常的地址。</p>
<p>EXC_BAD_INSTRUCTION 指令异常，非法或未定义的指令或操作数。</p>
<p>EXC_BREAKPOINT 和跟踪、断点相关的异常</p>
<p>EXC_SYSCALL 系统调用</p>
<p>EXC_CRASH 异常的进程退出</p>
<h1 id="第十二章-虚拟内存"><a href="#第十二章-虚拟内存" class="headerlink" title="第十二章 虚拟内存"></a>第十二章 虚拟内存</h1><p>1.Mach和所有内核一样，代码中有很大一部分都在负责高效的管理虚拟内存。</p>
<p>2.vm_map：表示任务地址空间内的一个或多个虚拟内存区域。每一个区域都由一个独立的条目vm_map_entry表示，这些条目由一个双向链表vm_map_links维护。</p>
<p>vm_map_entry: 每一个vm_map_entry 都表示了虚拟内存中一块连续的区域。每一个这样的区域都可以通过指定的访问保护权限进行保护（和虚拟内存页面采用同样的权限，即r/w/x权限）。vm_map_entry 通常指向一个vm_object，但是也可以指向一个嵌套的vm_map，即子映射。</p>
<p>vm_object: 用于将vm_map_entry 和实际支撑的内存关联起来。这个数据结构包含一个 vm_page 的链表。</p>
<p>vm_page：vm_page真正表示了vm_object或部分vm_object。vm_page可以有多种状态：驻留内存、交换出、加密、干净和脏等。</p>
<p>3.每一个Mach任务都有一个自己的虚拟内存空间，任务的struct task 中的map字段保存的就是这个虚拟内存空间。</p>
<p>4.purgeable的对象在内存低的情况下可能会丢失，即直接释放，而不是提交到后备存储。</p>
<p>5.Mach的API比POSIX提供的等同API要强大得多，主要是因为Mach API允许一个任务入侵到另一个任务的地址空间。为了访问其他任务的地址空间，要求有相应的权限（具体来说就是任务的端口）。除了这点要求之外，这些调用几乎是无所不能的。事实上，在OS X中很多进程入侵和线程注入技术都依赖这些Mach调用，而不是依赖BSD提供的调用。</p>
<p>6.vmmap()的例子可以很容易扩展得更具有入侵性，比如可以将进程内存映射导出到磁盘，甚至可以写入内存映射。</p>
<p>7.pmap可以嵌套（即包含其他pmap）。这是一个非常常见的技术，共享内存严重依赖这项技术——包括隐式的共享内存（共享库）和显式的共享内存（mmap()）。</p>
<p>8.Mach Zone的概念相当于Linux的内存缓存和Windows的Pool。Zone是一种内存区域，用于快速分配和释放频繁使用的固定大小的对象。Zone的API是内核内部使用的，在用户态不可使用。内核中的Zone和malloc的zone完全不同，后者是C运行时库的一部分，在用户态使用，而且具有很好的文档。</p>
<p>BSD内核zone 直接构建与Mach的zone之上。</p>
<p>9.如果系统内存不足，zone可能会进行垃圾回收。垃圾回收是一个两趟的过程，系统首先扫描所有的zone（跳过标记为不可回收的zone），检查这些zone的空闲列表，判断哪些对象是可以回收的。在第二趟中，将这些对象转换为页面：和非空闲对象共享了一个页面的对象不能被释放，只有页面全部空闲的对象才能被释放。最后，当判定好了可以释放的页面之后，通过kmem_free()释放。</p>
<p>10.所有的内核分配（除了连续物理内存的分配）的路径最终都会到达一个函数，那就是kernel_memory_allocate()。</p>
<p>11.进程的内存需求早晚会超过可用的RAM，系统必须有一种方法能将不活动的页面备份起来并且从RAM中删除，腾出更多的RAM给活动的页面使用，至少暂时能够满足活动页面的需求。在其他的操作系统中，这个工作是由专门的内核线程完成的。例如，Linux中的pdflush和wswapd内核线程。在Mach中，这些专用的任务成为分页器，分页器可以是内核线程，甚至可以是外部的用户态服务程序。</p>
<p>这里提到的分页器及基金实现了各自负责的内存对象的分页操作。这些分页器不会控制系统的分页侧路。分页策略是由vm_pageour守护线程负责的，而vm_pageout守护线程是kernel_bootstrap_thread()完成所有任务之后最后变成的。</p>
<p>12.Mach通过Universal Page List（统一页列表）这个数据结构来维护页的信息，这个列表和分页器的具体实现无关。UPL是连接虚拟地址和实际的物理页面的纽带，有一点类似于Windows的Memory Descriptor List和IOKit的IOMemoryDescriptor。</p>
<p>13.Vnode分页器负责支持文件的内存映射。当内存映射了文件，这些文件的内容需要从文件系统中读取。当内存映射的文件在内存中“脏”了，那么这些脏的页面需要写回文件系统。解密的页面永远不会被标记为脏，因此永远都不会被换出到磁盘上（如果可以从交换文件中提取到明文，那么整个加密就没有意义了）。</p>
<p>14.通过DYLD_INSERT_LIBRARIES强制注入一个库，然后直接从任务中读取内存。这也是为什么尽管App Store的二进制文件被加密，但是iOS应用程序的破解依然很繁荣的原因。</p>
<p>15.pageout守护程序其实不是一个真正的守护程序，而是一个线程。vm_pageout永不返回。初始化之后会派生出两个线程：外部的iothread，和一个垃圾回收线程（其实还有第三个线程，内部的iothread，是默认分页器注册时创建的）。设置完成后，vm_pageout()最终调用vm_pageout_continue()，这个函数周期性的唤醒并执行vm_pageout_scan()。</p>
<p>16.BSD层的Jetsam机制类似于Linux的Low Memory Killer。</p>
<p>17.在iOS中，物理内存非常紧缺而且没有交换空间，这个宏调用了vm_check_memorystatus()，而后者负责唤醒kernel_memorystatus线程，这属于Jetsam机制的一部分。</p>
<p>18.vm_fault()函数调用vm_page_fault()处理实际发生错误（缺页中断）的页面，并且从后备存储中将这个页面取回。实现方法是：查找vm_page对应的vm_object，然后从中获得分页器的端口，分页器的data_request函数负责从后备存储中读入要换入的页面。如果需要的话，换入操作还会对页面进行解密（如果页面在加密的交换文件中），并且验证代码签名。</p>
<p>19.非法访问：访问一个没有映射到进程地址空间（即任务的vm_map）的地址。解引用一个野指针时通常会发生这种错误。发生这种错误时进程会收到SIGSEGV信号。</p>
<p>20.页面保护错误：访问一个映射的地址，但是页面的保护掩码拒绝请求的访问。通常引发这个错误的原因包括跳转到数据段或试图写入（或读取）一个不允许写入（或不允许读取）的页面。发生这种错误时进程会收到SIGBUS信号。</p>
<p>21.dynamic_pager()是一个用户态的守护程序，负责维护系统交换文件，默认情况下交换文件在/private/var/vm/swapfile目录下。内核的default_pager分页器需要在用户态的干预下调整或修改交换条件时，从内核态调用这个守护程序。</p>
<h1 id="第十三章-BSD层"><a href="#第十三章-BSD层" class="headerlink" title="第十三章 BSD层"></a>第十三章 BSD层</h1><p>1.Mach只是一个微内核。尽管Mach的部分应用程序编程接口（API）也暴露给了用户态，但是开发者主要使用的还是更为流行的POSIX API，而这一套API是通过Mach之上的BSD层实现的。</p>
<p>2.ptrace()属于进程控制相关的调用。</p>
<p>3.在Mach提供的这些原语之上还需要建立一个层次提供像文件、设备、用户和组等重要从抽象。Mach最早选择的这个层次就是BSD，而且延续在XNU中了。</p>
<p>4.BSD采用了两个原语，并且组织成立UNIX世界上著名的进程和线程的概念。</p>
<p>5.BSD的进程可以唯一的映射到Mach任务，但是包含的信息比Mach任务提供的基本调度和统计信息要丰富。其中最值得注意的是，BSD进程包含了文件描述符和信号处理程序的数据。进程还支持复杂的谱系，将进程和其父进程、兄弟进程和子进程连接起来。</p>
<p>6.进程就是容器，二进制代码的实际执行单元是线程。</p>
<p>7.用户态的线程始于对pthread_create的调用。这个函数做的工作并不多，因为主要工作是由bsdthread_create()系统调用完成的，bsdthread_create()只不过是对Mach线程创建的复杂包装。真正的线程创建是由底层的Mach层完成的。bsdthread_create()负责的工作是设置线程栈（如果指定了自定义栈），设置（机器相关的）线程状态，以及设置自定义调度参数（如果提供了的话）等。</p>
<p>8.在UNIX中，进程不能被创建出来，只能通过fork()系统调用复制出来。如果fork()操作失败，fork()只会在调用的进程中返回-1。</p>
<p>9.子进程是父进程的完整复制，除了一下几个重要的例外：</p>
<p>①文件描述符，尽管数值和指向的文件都是一样，但只是原始描述符的副本。这意味着后续对这些描述符修改的调用（例如lseek()和close()）只会影响创建这些描述符的进程。</p>
<p>②资源限制，子进程会继承资源限制，但是资源利用率都设置为0。</p>
<p>③子进程的内存映像看上去是子进程私有的，但是事实上子进程和父进程使用的是内存中相通的物理页面。虚拟内存的私有性是通过设置页面的写时复制标志位来保证的，因此不论是哪个进程试图写入页面时都会引发页错误，从而创建页面的副本，并且重新建立映射。</p>
<p>10.vfork()的进程没有对应的Mach任务和线程。只有在接下来调用了execve()之后才会创建任务和线程。事实上，除了有一个execve()跟在后面之外，vfork()没有存在的意义，因为这个系统调用最初的设计就是为了这个目的。子进程的 task_t 和 thread_t （可以分别通过mach_task_self()和mach_thread_self()获得）完全就是父进程的 task_t 和 thread_t ，vm_map也是如此，只有以后调用 execve()载入一个Mach-O镜像才能最终真正创建一个Mach任务和进程。</p>
<p>11.如果将一个进程比作是一个人体，那么在进程中执行的二进制程序就是这个人体的大脑。只是通过fork()新创建出来的进程也没有多大作用，除非执行镜像通过exec()替换为另一个可执行程序。因此，进程创建的核心在于二进制文件的加载和执行。</p>
<p>12.execsw镜像加载器。进程执行镜像的流程太长了，这里不做记录，还是直接看书吧，</p>
<p>13.所有的镜像加载的路径要么终止在一个错误上，要么最终完成加载Mach镜像。</p>
<p>14.XNU中的Mach-O加载逻辑基本上和NeXT在1988年发明这个格式时差不多。经过这么多年苹果对这个过程做了一些修改，其中主要针对代码解密部分进行修改，但是Mach-O文件格式基础基本没什么变化。</p>
<p>苹果将这个修改封装在 exec_mach_imgact()中了，这是Mach二进制文件注册的处理程序。这个函数首先读取Mach文件头，然后解析其架构（32位或64位）和标志位。这个函数拒绝接受Dylib和Bundle文件——这些文件是由用户态的dyld动态链接器负责的。然后再应用posix_spawn()中的参数（如果有的话）。之后，对二进制进行评估以确保满足当前架构的需求。</p>
<p>处理Mach-O加载的主要函数是load_machfile()。load_machfile()函数负责设置内存映射，这个映射最终会加载各种 LC_SEGMENT 命令加载的数据。</p>
<p>Load_machfile()的核心在于parse_machfile。这个函数负责实际解析加载命令的繁杂工作。</p>
<p>其中，load_code_signature 也是load_machfile()函数里众多流程中的一个步骤，也就是验证代码签名。</p>
<p>经过三趟扫描后，在dlp变量中有一个保存的动态链接器命令，将动态链接器加载到新的映射中，可能要根据ASLR偏移进行调整。load_dylinker()函数会递归的调用parse_machfile()。</p>
<p>如果load_machfile()成功返回了，exec_mach_imgact会继续完成后续的工作。具体操作如下：</p>
<p>①通过调用vm_map_set_user_write_limit设置ulimit-m；</p>
<p>②设置代码签名的标志：</p>
<p>​ CS_HARD：拒绝加载无效页；</p>
<p>​ CS_KILL：如果有任何无效页则杀掉进程；</p>
<p>​ CS_EXEC_*：和上面两个标志位一样，只不过来自execve()。</p>
<p>③设置新的进程名称等等。</p>
<p>需要注意的是，这里并没有强制任何事情：真正的代码签名实施是在Mach的VM页错误处理程序中，通过调用 cs_invalid_page 来强制实施策略。</p>
<p>15.Mach提供了丰富的跟踪机制，其中最重要的就是DTrace。另一个机制ptrace()，这个机制在OS X和iOS（故意的）上只有部分功能有效。</p>
<p>16.BSD和其他UNIX系统提供了一个名为ptrace()的一站式系统调用，这个调用支持进程跟踪和调试。这个系统调用对于调试和逆向工程来说非常有用，例如在Linux中，gdb，系统调用跟踪（strace）和库函数调用跟踪（ltrace）就是用了这个系统调用。</p>
<p>17.在Linux中，ptrace的真正实力在于能够读写其他进程的内存，而XNU的ptrace实现则忽略了这些选项。不过Mach的API也能实现类似的功能。</p>
<p>18.挂起一个进程相当于停止一个进程的执行无限长时间，知道这个进程被恢复。冷冻和解冻的决定权通常都在iOS的加载器SpringBoard手中。</p>
<p>19.Mach已经通过异常机制提供了底层的陷阱处理，而BSD则在异常机制之上构建了信号处理机制。硬件产生的信号被Mach层捕捉，然后转换为对应的UNIX信号。为了维护一个统一的机制，操作系统和用户产生的信号首先被转换为Mach异常，然后再转换为信号。</p>
<p>20.当一个BSD进程（也是用户态进程）被bsdinit_task()函数启动时，这个函数还调用了 ux_handler_init()函数，这个函数设置了一个名为 ux_handler 的Mach内核线程。只有在 ux_handler_init()函数返回之后，bsdinit_task() 才能够注册使用 ux_exception_port。</p>
<p>通过调用 host_set_exception_ports()函数，bsdinit_task() 将所有的Mach异常消息都重定向到 ux_exception_port，这个端口由 ux_handler() 线程持有。由于所有后创建的用户态进程都是PID 1的后台，所以这些进程都会自动继承这个异常端口，相当于 ux_handler() 线程要负责处理系统上 UNIX 进程产生的每一个Mach异常。</p>
<p>ux_handler()函数非常简单，这个函数在进入时首先设置好 ux_handler_port，然后进入一个无限的Mach消息循环。消息循环接收Mach异常消息，然后调用mach_exc_server()处理异常。</p>
<p>mach_exc_server会调用mach_exception_raise()，然后会被mach_catch_exception_raise()捕获，信号处理逻辑就在这里。</p>
<p>21.硬件产生的信号始于处理器陷阱。处理器陷阱是平台相关的。ux_exception负责将陷阱转换为信号。</p>
<p>如果信号不是由硬件产生的，那么这个信号来源于两个API调用：kill()或pthread_kill()。这两个函数分别向进程和线程发送信号。</p>
<img src="/blogwebpage/images/system/unixsignal.png" class="" title="Mach异常到UNIX信号映射">


<h1 id="第十四章-BSD的高级功能"><a href="#第十四章-BSD的高级功能" class="headerlink" title="第十四章 BSD的高级功能"></a>第十四章 BSD的高级功能</h1><p>1.虚拟内存管理是在Mach层进行的，Mach控制了分页器，并且向用户态导出了各种vm_和mach_vm_消息接口。而用户态的开发者大部分都只知道标准的POSIX调用，因此需要对这些Mach调用进行封装。类似的，BSD层也使用了自己的内存管理函数。</p>
<p>2.OS X和iOS实现了一个低内存情形的处理机制，成为Jetsam，或者称为Memorystatus。这个机制有点类似于Linux的“out-of-memory”杀手，最初的用途就是杀掉消耗太多内存的进程。Jetsam的名字来源于杀掉消耗内存最多的进程并且抛弃这些进程占用的内存页面的过程。</p>
<p>3.Memorystaus维护了两个列表：一个是快照列表，这个列表保存了系统中所有进程的状态以及消耗的内存页面数；还有一个优先级列表，保存了要杀掉的备选进程。</p>
<p>4.用户态也可以通过pid_suspend()和pid_resume()控制进程的休眠。</p>
<p>5.ASLR：Address Space Layout Randomization 内核地址空间布局随机化。</p>
<p>ASLR对内核代码的影响非常小：代码不再使用固定地址，而是转变为使用相对地址，相对地址是针对程序的当前位置确定的。</p>
<p>6.工作队列是OS X中开发的一项机制，作用是为应用程序提供多线程并扩展到多处理器支持。工作队列是GCD的基础机制。</p>
<p>7.overcommit位表示这个队列可以创建新的线程。通常情况下不建议使用这个策略，因为线程数多于CPU数会降低程序的运行速度。</p>
<p>GCD仅通过dispatch_get_global_queue调用可以接受的一个标志（DISPATCH_QUEUE_OVERCOMMIT）来支持overcommit，但是苹果的文档掩盖了这个事实，宣称这个标志位必须为0。</p>
<p>GCD和libdispatch在工作队列不存在或被禁用时也能工作，在这种情况下，GCD和libdispatch会退而使用线程池模型。</p>
<p>补充：</p>
<p>_dispatch_get_root_queue 会获取一个全局队列，它有两个参数，分别表示优先级和是否支持 overcommit。一共有四个优先级，LOW、DEFAULT、HIGH 和 BACKGROUND，因此共有 8 个全局队列。带有 overcommit 的队列表示每当有任务提交时，系统都会新开一个线程处理，这样就不会造成某个线程过载(overcommit)。——参考自<span class="exturl" data-url="aHR0cHM6Ly9iZXN0c3dpZnRlci5jb20vZGVlcC1nY2Qv">https://bestswifter.com/deep-gcd/<i class="fa fa-external-link-alt"></i></span></p>
<p>阅读过 GCD 源码的同学会知道，所有默认创建的 GCD queue 都有一个优先级，但其实每个优先级对应两个 queue，比如一个是 default-priority， 那么另一个就是 default-priority-overcommit。dispatch_async 的时候，会首先将任务丢进 default-priority 队列，如果队列满了，就转而丢进 default-priority-overcommit。</p>
<p>在 Mac 系统里，GCD 允许 overcommit，意味着每次 dispatch_async 都会创建一个新线程，即使 over commit 了，这些过量的线程会根据优先级来竞争 CPU 资源。</p>
<p>而在 iOS 系统里，GCD 会控制 overcommit，如果某个优先级队列 over commit 里，那么排在后面的任务就会处于等待状态。移动设备 CPU 资源比较紧张，这种设计合乎常理。</p>
<p>所以如果在 iOS 里创建过多的 serial queue，那么后面提交的任务可能就会一直处于等待状态。这也是为什么我们需要严格控制 queue 的数量和层级关系，最好是 App 当中每个子系统只能分配固定数量和优先级的 queue，从而避免 thread explosion 导致的代码无法及时执行问题。</p>
<p>——参考自<span class="exturl" data-url="aHR0cHM6Ly96aHVhbmxhbi56aGlodS5jb20vcC8zNzQ2MzA1NQ==">https://zhuanlan.zhihu.com/p/37463055<i class="fa fa-external-link-alt"></i></span></p>
<p>8.MAC：Mandatory Access Control 强制访问控制。</p>
<p>9.iOS的安全机制比OS X的安全机制严格得多。OS X中代码签名是可选的，而iOS会通过kill-9杀掉任何代码签名不正确的进程。</p>
<p>iOS中“坏警察”是由AMFL扮演的，AMFL在用户态也有一个守护程序：/usr/libexec/amfid。这个守护程序是由launchd启动的。也注册了一个主机特殊端口。</p>
<h1 id="第十五-十六章-文件系统"><a href="#第十五-十六章-文件系统" class="headerlink" title="第十五/十六章 文件系统"></a>第十五/十六章 文件系统</h1><p>1.ACL：Access Control List 访问控制列表。OS X允许通过chmod()设置和修改ACL。通过 ls -e 可以显示访问控制列表。 ——比如著名的chomd 777就是把文件改为可读可写可执行的状态</p>
<p>2.Unix要求维护3个时间戳：创建事件、修改时间和访问时间。</p>
<p>3.FIFO是UNIX对“具名管道”的实现。通过pipe()系统调用可以创建匿名管道，但是匿名管道不能在无关的进程间共享。</p>
<p>4.底层的文件系统可以是基于表的（例如FAT），也可以基于B树的（例如NTFS和HFS+）。</p>
<p>5.每一个操作系统都有一个自己的原生文件系统。DOS的原生文件系统是FAT，Windows的原生文件系统是NTFS，HFS+是OS X的原生文件系统。</p>
<p>6.内核不能执行压缩操作，而且也没有提供对外部压缩的支持：在内核层只支持解压缩。</p>
<p>7.HFS+使用的是UTF_16编码——双字节Unicode。HFS+也是大小写不敏感的文件系统。OS X 默认使用HFS+，iOS使用启动了大小写敏感的HFSX。</p>
<p>8.日志是磁盘中一块特殊的区域，用户看不见这个区域，文件系统在向磁盘提交事务之前会将事务记录在这个区域中。如果修改事务被成功提交，那么这些事务就会从日志中删除。但是如果发生了崩溃，文件系统可以快速恢复到一致的状态——要么重放日志（即提交所有记录的事务），要么回滚日志（如果包含未完成的事务）。</p>
<p>日志并不是解决数据丢失的灵丹妙药。然而，日志可以显著的减少系统崩溃导致文件系统无法使用的情况。</p>
<p>9.HFS+有一项很有意思很特别的特性是能够动态适应频繁访问的文件。HFS+为每一个文件维护一个热度值。HFS+能够在工作时进行碎片整理工作。</p>
<p>10.B树是一些文件系统构建的基础，例如NTFS（Windows）、Ext4（Linux）和苹果的HFS及HFS+。</p>
<p>11.任何文件系统最基本的概念就是用于保存和取得文件的机制。需要满足的需求包括：搜索、插入、更新和随机访问。</p>
<p>大部分文件系统都采用了基于树的方案。根据树形结构的设计，上述的要求都能满足，而且还很自然的提供了层次结构，这是平坦的表示结构无法提供的。</p>
<p>12.B数可以看成是二叉树的扩展，相似的地方在于都采用了树形结构，而不同的地方在于B树的节点可以有任意数据的子节点——定义为m——而不只是两个子节点。这种结构可以帮助限制树的深度，从log2(N)（典型的二叉树搜索时间复杂度），到最优情况的logm(N)以及最坏情况的logm/2(N)。</p>
<p>13.和所有的树一样，B树由节点组成，但是和其他树不一样的地方在于，B树的节点可以有具体的子类型，或称为kind。不同的节点类型可以保存不同的数据，但是所有类型的节点都来源于一个基本类型（可以看成是一个基类）。</p>
<p>为了遍历所有的记录，在节点尾部向头部方向依次保存了指向每一条记录的指针，其中也包含节点中包含的任何空闲空间使用的空记录的指针。</p>
<p>14.HFS+的B树总是有一个固定的深度。也就是说，所有的叶子节点都在同一层上。</p>
<p>15.当HFS+挂载时启动了日志功能，那么还会启用一个日志文件。</p>
<h1 id="其他部分-网络协议栈-内核扩展模块-IOKit"><a href="#其他部分-网络协议栈-内核扩展模块-IOKit" class="headerlink" title="其他部分 网络协议栈/内核扩展模块/IOKit"></a>其他部分 网络协议栈/内核扩展模块/IOKit</h1><p>1.一般的Cocoa开发者并不需要了解套接字相关的知识。因为CoreFoundation通过CFNetwork提供了封装了套接字的CFSocket和CFStream，此外还提供了一些协议的封装，例如CFFTP、CFHTTP等。尽管如此，BSD套接字是XNU中所有网络组件的核心（实际上也是所有现代操作系统的核心）。</p>
<img src="/blogwebpage/images/system/other.png" class="" title="网络">


<p>2.模块化设计是可扩展性之母。</p>
<p>3.代码签名，如今已经被大多数系统采纳为标准。Windows是一个典型实例，只允许加载具有合法数字签名的驱动程序。在控制权转交给模块入口点之前，内核会验证代码签名，代码签名保存在附加的证书中。证书必须通过私钥签名，内核已知公钥，内核也可以通过一个信任链获得这样一个秘钥。</p>
<p>早在iBoot阶段，未经苹果签名的代码就不能被加载。</p>
<p>4.预链接是苹果在OS X和iOS中使用的方法。引导加载器不按照先加载内核，再以一定顺序加载kext的方式进行加载，而是加载一个kernelcache文件。——好处是加载的速度快得多，并且kernelcache可以添加签名，甚至还可以加密，一旦加载了kernelcache，就可以禁止所有kext加载，这样可以阻断代码进入iOS内核的合法通道。</p>
<p>5.IOKit有一个顶层的抽象基类是OSObject。</p>
<p>6.IOKit提供了一个工作循环（work loop）模型，有一点类似于Objective-C的runloop（或Mach的消息循环）。简而言之，工作循环是一个不断处理事件的消息处理循环。通过使用工作循环可以极大的简化并发问题，而且通常可以避免对锁的使用，锁是会影响性能的。</p>
<p>7.IOKit采用了NeXT的runloop模型，用户态开发者应该会想到CFRunLoop。IOKit版本的runloop成为IOWorkloop，基本思想是一样的：提供一个单线程且线程安全的机制处理所有类型的事件，如果不采用这种机制则是异步的。工作循环的访问被一个互斥体保护，因此不需要考虑可重入的问题以及线程安全的问题。不过要注意的是，不能保证工作循环确实是一个线程。也就是说，工作循环的迭代可能会运行在系统中另一个线程的上下文中。</p>
<p>8.上下文切换：是另一种类型的控制权转移，上下文切换指的是将当前正在执行的线程的上下文切换为另一个线程的上下文。</p>
<p>9.ARM和Intel处理器都在处理器层次提供了线程的支持。事实上，这也是为什么现代操作系统都不调度进程，而是调度线程的原因。</p>
<p>10.在现代操作系统中，实现并发的先决条件是具有能够提供安全锁定机制的能力，通过这种方式能够同步共享资源的访问。同步机制通常都依赖于硬件的支持，因此在ARM和Intel架构上的实现是不同的。Mach底层的hw_lock_lock()函数的实现时候一个很好的示例。从内核的角度看，这个函数提供的方法总是一直的：快速的自旋锁。</p>
<p>11.原子操作是和锁非常接近的功能。院子操作是一类保证了原子性（atomicity，几不可中断性）的操作。原子操作常作为锁操作的底层机制（因为必须以原子的方式访问锁），而且经常可以替代锁的使用（当要保护的对象为机器字大小时）。</p>
<p>原子不一定意味着单周期，原子的意思只是说CPU保证在访问的过程中不会被打断。</p>
<p>12.为了能够最优化的利用内部组件（例如ALU，FPU和加载/存储组件），现代的CPU会采用乱序的方式执行指令。然而在某些情况下，乱序执行可能会在程序中引入bug。在这种情况下，可以使用屏障（barrier）指令来确保程序执行到某个点时所有访问操作都完成了。——比如iOS的内存屏障</p>

      
    </div>

    
    
    
      <footer class="post-footer">
        <div class="post-eof"></div>
      </footer>
  </article>
  
  
  

      
  
  
  <article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-CN">
    <link itemprop="mainEntityOfPage" href="https://wangkejie.gitee.io/blogwebpage/iOS/thirdpart/glide.html">

    <span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
      <meta itemprop="image" content="/blogwebpage/images/avatar.gif">
      <meta itemprop="name" content="Jack Wang">
      <meta itemprop="description" content="书山有路勤为径，学海无涯苦作舟！">
    </span>

    <span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
      <meta itemprop="name" content="王科杰">
    </span>
      <header class="post-header">
        <h2 class="post-title" itemprop="name headline">
          
            <a href="/blogwebpage/iOS/thirdpart/glide.html" class="post-title-link" itemprop="url">Glide</a>
        </h2>

        <div class="post-meta">
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-calendar"></i>
              </span>
              <span class="post-meta-item-text">发表于</span>

              <time title="创建时间：2019-12-09 10:26:12" itemprop="dateCreated datePublished" datetime="2019-12-09T10:26:12+08:00">2019-12-09</time>
            </span>
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-folder"></i>
              </span>
              <span class="post-meta-item-text">分类于</span>
                <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
                  <a href="/blogwebpage/categories/Android/" itemprop="url" rel="index"><span itemprop="name">Android</span></a>
                </span>
            </span>

          

        </div>
      </header>

    
    
    
    <div class="post-body" itemprop="articleBody">

      
          <h1 id="逐步分析"><a href="#逐步分析" class="headerlink" title="逐步分析"></a>逐步分析</h1><h2 id="Glide-with-……"><a href="#Glide-with-……" class="headerlink" title="Glide.with(……)"></a>Glide.with(……)</h2><p>Glide.with() 有下面几种实现方式。</p>
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="number">1.</span> Glide.with(Context context)</span><br><span class="line"><span class="number">2.</span> Glide.with(Activity activity)</span><br><span class="line"><span class="number">3.</span> Glide.with(FragmentActivity activity)</span><br><span class="line"><span class="number">4.</span> Glide.with(android.app.Fragment fragment)</span><br><span class="line"><span class="number">5.</span> Glide.with(View view)</span><br></pre></td></tr></table></figure>

<p>所以的方法实现也是很类似，都是调用同一个方法</p>
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">public</span> <span class="keyword">static</span> RequestManager <span class="title">with</span><span class="params">(Fragment fragment)</span> </span>&#123;</span><br><span class="line">  <span class="keyword">return</span> getRetriever(fragment.getActivity()).get(fragment);</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>
<p>再看一下 getRetriever() 方法</p>
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">private</span> <span class="keyword">static</span> RequestManagerRetriever <span class="title">getRetriever</span><span class="params">(<span class="meta">@Nullable</span> Context context)</span> </span>&#123;</span><br><span class="line">  ……</span><br><span class="line">  省略一些判空检查</span><br><span class="line">  ——</span><br><span class="line">  <span class="keyword">return</span> Glide.get(context).getRequestManagerRetriever();</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>
<p>其中 Glide.get(context) 主要用来初始化 Glide 的全局单利对象，以及一些配置。</p>
<p>getRequestManagerRetriever() 则是返回 Glide 对象的 requestManagerRetriever 对象。</p>
<p>然后看一下 requestManagerRetriever.get() 方法</p>
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">public</span> RequestManager <span class="title">get</span><span class="params">(Context context)</span> </span>&#123;</span><br><span class="line">  <span class="keyword">if</span> (context == <span class="keyword">null</span>) &#123;</span><br><span class="line">    <span class="keyword">throw</span> <span class="keyword">new</span> IllegalArgumentException(<span class="string">&quot;You cannot start a load on a null Context&quot;</span>);</span><br><span class="line">  &#125; <span class="keyword">else</span> <span class="keyword">if</span> (Util.isOnMainThread() &amp;&amp; !(context <span class="keyword">instanceof</span> Application)) &#123;</span><br><span class="line">    <span class="keyword">if</span> (context <span class="keyword">instanceof</span> FragmentActivity) &#123;</span><br><span class="line">      <span class="keyword">return</span> get((FragmentActivity) context);</span><br><span class="line">    &#125; <span class="keyword">else</span> <span class="keyword">if</span> (context <span class="keyword">instanceof</span> Activity) &#123;</span><br><span class="line">      <span class="keyword">return</span> get((Activity) context);</span><br><span class="line">    &#125; <span class="keyword">else</span> <span class="keyword">if</span> (context <span class="keyword">instanceof</span> ContextWrapper) &#123;</span><br><span class="line">      <span class="keyword">return</span> get(((ContextWrapper) context).getBaseContext());</span><br><span class="line">    &#125;</span><br><span class="line">  &#125;</span><br><span class="line"></span><br><span class="line">  <span class="keyword">return</span> getApplicationManager(context);</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>
<p>get() 方法会根据传入的 context 对象和当前线程，创建不同的 RequestManager 实例</p>
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="number">1.</span> 非 UI 线程，返回 applicationManager 对象，能感知 Application 生命周期。</span><br><span class="line"><span class="number">2.</span> UI 线程，如果 context 是 Activity 、FragmentActivity </span><br><span class="line">   则会创建一个能感知对应 Activity 的 RequestManager。</span><br><span class="line"><span class="number">3.</span> UI 线程，如果 Context 是 Fragment、android.support.v4.app.Fragment </span><br><span class="line">   则会创建一个能感知对应 Fragment 生命周期 的 RequestManager。</span><br></pre></td></tr></table></figure>
<p>这里反复提到了一个 <code>感知生命 xx 周期</code>，也是 Glide 的一个特性。</p>
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">Glide 在加载资源的时候，如果是在 Activity、Fragment 这一类有生命周期的组件上进行。</span><br><span class="line">当 Activity、Fragment 等组件进入不可见，或者已经销毁的时候，Glide 会停止加载资源。</span><br><span class="line">Application 的生命周期贯穿整个应用，所以 applicationManager 只有在应用程序关闭的时候终止加载。</span><br></pre></td></tr></table></figure>
<p>所以尽量不要在非 UI 线程使用 Glide 加载图片，尽量使用 Activity、Fragment 等带有生命周期的组件配合 Glide 使用。</p>
<h2 id="Glide-如何获得-Activity、Fragment-生命周期回调"><a href="#Glide-如何获得-Activity、Fragment-生命周期回调" class="headerlink" title="Glide 如何获得 Activity、Fragment 生命周期回调"></a>Glide 如何获得 Activity、Fragment 生命周期回调</h2><p>在 各种 requestManagerRetriever.get() 方法中如果传入的是带有生命周期的组件，并且在 UI 线程，会执行以下几个方法端</p>
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">// FragmentActivity</span></span><br><span class="line">assertNotDestroyed(activity);</span><br><span class="line">FragmentManager fm = activity.getSupportFragmentManager();</span><br><span class="line"><span class="keyword">return</span> supportFragmentGet(activity, fm, <span class="keyword">null</span> <span class="comment">/*parentHint*/</span>);</span><br><span class="line"></span><br><span class="line"><span class="comment">//android.support.v4.app.Fragment</span></span><br><span class="line">FragmentManager fm = fragment.getChildFragmentManager();</span><br><span class="line"><span class="keyword">return</span> supportFragmentGet(fragment.getActivity(), fm, fragment);</span><br><span class="line"></span><br><span class="line"><span class="comment">//Activity</span></span><br><span class="line">assertNotDestroyed(activity);</span><br><span class="line">android.app.FragmentManager fm = activity.getFragmentManager();</span><br><span class="line"><span class="keyword">return</span> fragmentGet(activity, fm, <span class="keyword">null</span> <span class="comment">/*parentHint*/</span>);</span><br><span class="line"></span><br><span class="line"><span class="comment">//android.app.Fragment</span></span><br><span class="line">android.app.FragmentManager fm = fragment.getChildFragmentManager();</span><br><span class="line"><span class="keyword">return</span> fragmentGet(fragment.getActivity(), fm, fragment);</span><br></pre></td></tr></table></figure>
<ol>
<li>如果是 Activity ，先获取 FragmentManager ，如果是 Fragment 则先获取 ChildFragmentManager。</li>
<li>如果是 support 包下面的 Activity 、Fragment 调用 supportFragmentGet，否则调用 fragmentGet。</li>
</ol>
<p>fragmentGet() 和 supportFragmentGet() 方法大致类似，选取一个分析一下。</p>
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">private</span> RequestManager <span class="title">fragmentGet</span><span class="params">(Context context, android.app.FragmentManager fm,</span></span></span><br><span class="line"><span class="function"><span class="params">    android.app.Fragment parentHint)</span> </span>&#123;</span><br><span class="line">  RequestManagerFragment current = getRequestManagerFragment(fm, parentHint);</span><br><span class="line">  RequestManager requestManager = current.getRequestManager();</span><br><span class="line">  <span class="keyword">if</span> (requestManager == <span class="keyword">null</span>) &#123;</span><br><span class="line">    <span class="comment">// TODO(b/27524013): Factor out this Glide.get() call.</span></span><br><span class="line">    Glide glide = Glide.get(context);</span><br><span class="line">    requestManager =</span><br><span class="line">        factory.build(</span><br><span class="line">            glide, current.getGlideLifecycle(), current.getRequestManagerTreeNode(), context);</span><br><span class="line">    current.setRequestManager(requestManager);</span><br><span class="line">  &#125;</span><br><span class="line">  <span class="keyword">return</span> requestManager;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>
<p>上面这段代码做了两个功能</p>
<figure class="highlight angelscript"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="number">1.</span> 创建一个 RequestManagerFragment。</span><br><span class="line"><span class="number">2.</span> 创建一个 RequestManager。</span><br></pre></td></tr></table></figure>
<p>先看一下 getRequestManagerFragment</p>
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)</span></span><br><span class="line"><span class="function">RequestManagerFragment <span class="title">getRequestManagerFragment</span><span class="params">(</span></span></span><br><span class="line"><span class="function"><span class="params">    <span class="keyword">final</span> android.app.FragmentManager fm, android.app.Fragment parentHint)</span> </span>&#123;</span><br><span class="line">  RequestManagerFragment current = (RequestManagerFragment) fm.findFragmentByTag(FRAGMENT_TAG);</span><br><span class="line">  <span class="keyword">if</span> (current == <span class="keyword">null</span>) &#123;</span><br><span class="line">    current = pendingRequestManagerFragments.get(fm);</span><br><span class="line">    <span class="keyword">if</span> (current == <span class="keyword">null</span>) &#123;</span><br><span class="line">      current = <span class="keyword">new</span> RequestManagerFragment();</span><br><span class="line">      current.setParentFragmentHint(parentHint);</span><br><span class="line">      pendingRequestManagerFragments.put(fm, current);</span><br><span class="line">      fm.beginTransaction().add(current, FRAGMENT_TAG).commitAllowingStateLoss();</span><br><span class="line">      handler.obtainMessage(ID_REMOVE_FRAGMENT_MANAGER, fm).sendToTarget();</span><br><span class="line">    &#125;</span><br><span class="line">  &#125;</span><br><span class="line">  <span class="keyword">return</span> current;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>
<p>这是是 Glide 设计中比较一个巧妙的地方</p>
<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">创建一个透明的 RequestManagerFragment 加入到FragmentManager 之中</span><br><span class="line">通过添加的这个 Fragment 感知 Activity 、Fragment 的生命周期。</span><br></pre></td></tr></table></figure>
<p>在 RequestManagerFragment 中可以看到以下代码</p>
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">@Override</span></span><br><span class="line"><span class="function"><span class="keyword">public</span> <span class="keyword">void</span> <span class="title">onStart</span><span class="params">()</span> </span>&#123;</span><br><span class="line">  <span class="keyword">super</span>.onStart();</span><br><span class="line">  lifecycle.onStart();</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="meta">@Override</span></span><br><span class="line"><span class="function"><span class="keyword">public</span> <span class="keyword">void</span> <span class="title">onStop</span><span class="params">()</span> </span>&#123;</span><br><span class="line">  <span class="keyword">super</span>.onStop();</span><br><span class="line">  lifecycle.onStop();</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="meta">@Override</span></span><br><span class="line"><span class="function"><span class="keyword">public</span> <span class="keyword">void</span> <span class="title">onDestroy</span><span class="params">()</span> </span>&#123;</span><br><span class="line">  <span class="keyword">super</span>.onDestroy();</span><br><span class="line">  lifecycle.onDestroy();</span><br><span class="line">  unregisterFragmentWithRoot();</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>
<p>可以通过 RequestManagerFragment 把 Activity 的生命周期通过 lifecycle 传递给在 lifecycle 注册的 LifecycleListener。</p>
<h2 id="RequestManager-load-url"><a href="#RequestManager-load-url" class="headerlink" title="RequestManager.load(url)"></a>RequestManager.load(url)</h2><figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">public</span> RequestBuilder&lt;Drawable&gt; <span class="title">load</span><span class="params">(<span class="meta">@Nullable</span> Object model)</span> </span>&#123;</span><br><span class="line">  <span class="keyword">return</span> asDrawable().load(model);</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">public</span> RequestBuilder&lt;Drawable&gt; <span class="title">asDrawable</span><span class="params">()</span> </span>&#123;</span><br><span class="line">  <span class="keyword">return</span> as(Drawable.class);</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="keyword">public</span> &lt;ResourceType&gt; <span class="function">RequestBuilder&lt;ResourceType&gt; <span class="title">as</span><span class="params">(Class&lt;ResourceType&gt; resourceClass)</span> </span>&#123;</span><br><span class="line">  <span class="keyword">return</span> <span class="keyword">new</span> RequestBuilder&lt;&gt;(glide, <span class="keyword">this</span>, resourceClass, context);</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">public</span> RequestBuilder&lt;TranscodeType&gt; <span class="title">load</span><span class="params">(<span class="meta">@Nullable</span> Object model)</span> </span>&#123;</span><br><span class="line">  <span class="keyword">return</span> loadGeneric(model);</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">private</span> RequestBuilder&lt;TranscodeType&gt; <span class="title">loadGeneric</span><span class="params">(<span class="meta">@Nullable</span> Object model)</span> </span>&#123;</span><br><span class="line">  <span class="keyword">this</span>.model = model;</span><br><span class="line">  isModelSet = <span class="keyword">true</span>;</span><br><span class="line">  <span class="keyword">return</span> <span class="keyword">this</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>
<p>以上就是 RequestBuilder.load(url) 的相关代码，发现并没有什么特殊之处。 只是创建了一个 RequestBuilder 。</p>
<h2 id="RequestBuilder-into-view"><a href="#RequestBuilder-into-view" class="headerlink" title="RequestBuilder.into(view)"></a>RequestBuilder.into(view)</h2><p>into() 方法调用起来十分方便，只要传递一个 ImageView ，Glide 就会自动下载图片，并且显示到 ImageView 上。这看似十分简单的一步，也是 Glide 最负责的调用。</p>
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">public</span> Target&lt;TranscodeType&gt; <span class="title">into</span><span class="params">(ImageView view)</span> </span>&#123;</span><br><span class="line">  </span><br><span class="line">  RequestOptions requestOptions = <span class="keyword">this</span>.requestOptions;</span><br><span class="line">  ……</span><br><span class="line">  </span><br><span class="line">  <span class="keyword">return</span> into(</span><br><span class="line">      glideContext.buildImageViewTarget(view, transcodeClass),</span><br><span class="line">      <span class="comment">/*targetListener=*/</span> <span class="keyword">null</span>,</span><br><span class="line">      requestOptions);</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>
<p>跟踪一下 glideContext.buildImageViewTarget(view, transcodeClass) 会发现这里返回的是一个<code>DrawableImageViewTarget</code><br>into(ImageView view) 把 requestOptions 和 DrawableImageViewTarget 传入</p>
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">private</span> &lt;Y extends Target&lt;TranscodeType&gt;&gt; <span class="function">Y <span class="title">into</span><span class="params">(</span></span></span><br><span class="line"><span class="function"><span class="params">    <span class="meta">@NonNull</span> Y target,</span></span></span><br><span class="line"><span class="function"><span class="params">    <span class="meta">@Nullable</span> RequestListener&lt;TranscodeType&gt; targetListener,</span></span></span><br><span class="line"><span class="function"><span class="params">    RequestOptions options)</span> </span>&#123;</span><br><span class="line">  ……</span><br><span class="line">  Request request = buildRequest(target, targetListener, options);</span><br><span class="line"></span><br><span class="line">  Request previous = target.getRequest();</span><br><span class="line">  ……</span><br><span class="line">  requestManager.clear(target);</span><br><span class="line">  target.setRequest(request);</span><br><span class="line">  requestManager.track(target, request);</span><br><span class="line"></span><br><span class="line">  <span class="keyword">return</span> target;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>
<p>下一步跟踪到 requestManager.track(target, request)</p>
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"> <span class="function"><span class="keyword">void</span> <span class="title">track</span><span class="params">(Target&lt;?&gt; target, Request request)</span> </span>&#123;</span><br><span class="line">  targetTracker.track(target);</span><br><span class="line">  requestTracker.runRequest(request);</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">public</span> <span class="keyword">void</span> <span class="title">runRequest</span><span class="params">(Request request)</span> </span>&#123;</span><br><span class="line">  requests.add(request);</span><br><span class="line">  <span class="keyword">if</span> (!isPaused) &#123;</span><br><span class="line">    request.begin();</span><br><span class="line">  &#125; <span class="keyword">else</span> &#123;</span><br><span class="line">    pendingRequests.add(request);</span><br><span class="line">  &#125;</span><br><span class="line">&#125;  </span><br></pre></td></tr></table></figure>
<p>isPaused 变量</p>
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="number">1.</span> 如果此时 GlideRequests 的 Lifecycle 为 ApplicationLifecycle，只要应用存活</span><br><span class="line">   isPaused 为 <span class="keyword">false</span> ，直接执行 request.begin()</span><br><span class="line"><span class="number">2.</span> 如果 GlideRequests 的 Lifecycle 是观测 Fragment 或者 Activity</span><br><span class="line">   isPaused 为<span class="keyword">true</span> ,不会立即执行 request.begin()</span><br><span class="line">   当 Fragment 或者 Activity 显示到前台时通过遍历 requests 数组执行 request.begin()</span><br></pre></td></tr></table></figure>
<p>所以执行网络请求下载图片的操作在 request.begin() 之中。<br>回到 into(ImageView view) 方法的</p>
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">Request request = buildRequest(target, targetListener, options)</span><br></pre></td></tr></table></figure>
<p>经过层层包裹我们可以找到一下路线，发现最后返回的是 SingleRequest</p>
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">buildRequest &gt;&gt; buildRequestRecursive &gt;&gt; buildThumbnailRequestRecursive</span><br><span class="line"></span><br><span class="line">&gt;&gt; obtainRequest &gt;&gt; SingleRequest</span><br></pre></td></tr></table></figure>
<p>创建 SingleRequest 的过程比较复杂，牵扯到缩略图、错误处理之类的逻辑，大致都是上面那条路径。</p>
<p>然后就看一下 SingleRequest.begin()</p>
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">@Override</span></span><br><span class="line"><span class="function"><span class="keyword">public</span> <span class="keyword">void</span> <span class="title">begin</span><span class="params">()</span> </span>&#123;</span><br><span class="line">  ……</span><br><span class="line">  省略一些其他分支</span><br><span class="line">  ……</span><br><span class="line">  status = Status.WAITING_FOR_SIZE;</span><br><span class="line">  <span class="keyword">if</span> (Util.isValidDimensions(overrideWidth, overrideHeight)) &#123;</span><br><span class="line">    onSizeReady(overrideWidth, overrideHeight);</span><br><span class="line">  &#125; <span class="keyword">else</span> &#123;</span><br><span class="line">    target.getSize(<span class="keyword">this</span>);</span><br><span class="line">  &#125;</span><br><span class="line">  ……</span><br><span class="line">  ……</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>
<p>begin() 方法很长，我们剔除了一些异常处理，直接看最核心的方法。</p>
<p>如果我给 Glide 设置了 override() 则直接调用 onSizeReady(overrideWidth, overrideHeight)</p>
<p>否则会调用 target.getSize(this) 让 ImageView 计算自己的尺寸。</p>
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">glideContext.buildImageViewTarget(view, transcodeClass) 创建一个 DrawableImageViewTarget</span><br></pre></td></tr></table></figure>
<h2 id="Glide流程"><a href="#Glide流程" class="headerlink" title="Glide流程"></a>Glide流程</h2><img src="/blogwebpage/images/Android/glide-liucheng.png" class="" title="glide-process">

<h2 id="Glide网络下载流程"><a href="#Glide网络下载流程" class="headerlink" title="Glide网络下载流程"></a>Glide网络下载流程</h2><img src="/blogwebpage/images/Android/glide-netload.png" class="" title="glide-process">


<h1 id="总结"><a href="#总结" class="headerlink" title="总结"></a>总结</h1><ul>
<li>缓存<ul>
<li>活动资源 (Active Resources)</li>
<li>内存缓存 (Memory Cache)</li>
<li>资源类型（Resource Disk Cache）</li>
<li>原始数据 (Data Disk Cache)</li>
<li>网络缓存</li>
</ul>
</li>
</ul>

      
    </div>

    
    
    
      <footer class="post-footer">
        <div class="post-eof"></div>
      </footer>
  </article>
  
  
  

      
  
  
  <article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-CN">
    <link itemprop="mainEntityOfPage" href="https://wangkejie.gitee.io/blogwebpage/iOS/interview/index.html">

    <span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
      <meta itemprop="image" content="/blogwebpage/images/avatar.gif">
      <meta itemprop="name" content="Jack Wang">
      <meta itemprop="description" content="书山有路勤为径，学海无涯苦作舟！">
    </span>

    <span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
      <meta itemprop="name" content="王科杰">
    </span>
      <header class="post-header">
        <h2 class="post-title" itemprop="name headline">
          
            <a href="/blogwebpage/iOS/interview/index.html" class="post-title-link" itemprop="url">面试可能会问的</a>
        </h2>

        <div class="post-meta">
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-calendar"></i>
              </span>
              <span class="post-meta-item-text">发表于</span>

              <time title="创建时间：2019-09-15 11:26:39" itemprop="dateCreated datePublished" datetime="2019-09-15T11:26:39+08:00">2019-09-15</time>
            </span>
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-folder"></i>
              </span>
              <span class="post-meta-item-text">分类于</span>
                <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
                  <a href="/blogwebpage/categories/iOS/" itemprop="url" rel="index"><span itemprop="name">iOS</span></a>
                </span>
                  ，
                <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
                  <a href="/blogwebpage/categories/iOS/%E9%9D%A2%E8%AF%95%E5%8F%AF%E8%83%BD%E4%BC%9A%E9%97%AE%E7%9A%84/" itemprop="url" rel="index"><span itemprop="name">面试可能会问的</span></a>
                </span>
            </span>

          

        </div>
      </header>

    
    
    
    <div class="post-body" itemprop="articleBody">

      
          <p>问：</p>
<ul>
<li><p><a href="./iOS/interview/nsurlsession-connection.html">NSURLSession与NSURLConnection区别</a></p>
</li>
<li><p><a href="./iOS/interview/iosappsigning.html">苹果签名的原理</a></p>
</li>
<li><p><a href="./iOS/interview/protocol.html">面向协议编程</a></p>
</li>
<li><p><a href="./iOS/interview/delegate.html">HTTP代理的原理，抓包原理</a></p>
</li>
<li><p><a href="./iOS/interview/apppackage.html">app包体积的优化</a></p>
</li>
<li><p><a href="./iOS/interview/ipaanalysis.html">ipa的分析</a></p>
</li>
<li><p><a href="./iOS/interview/applaunchspeed.html">app启动速度优化</a></p>
</li>
<li><p><a href="./iOS/interview/pod.html">pod实现原理</a></p>
</li>
<li><p><a href="./iOS/interview/gcd-barrier.html">栅栏函数的用法</a></p>
</li>
<li><p>线程什么时候创建，RunLoop呢</p>
</li>
<li><p><a href="./iOS/interview/runloop.html">怎么主动休眠一个RunLoop, 我才应该是退出</a></p>
</li>
<li><p>一个线程代码里面只启动了一个RunLoop，没有其他任务，发生什么 </p>
</li>
<li><p>推流视频(暂时不写，以后工作中需要再补充)</p>
</li>
<li><p>还有什么，联系我，继续补充</p>
</li>
</ul>
          <!--noindex-->
            <div class="post-button">
              <a class="btn" href="/blogwebpage/iOS/interview/index.html#more" rel="contents">
                阅读全文 &raquo;
              </a>
            </div>
          <!--/noindex-->
        
      
    </div>

    
    
    
      <footer class="post-footer">
        <div class="post-eof"></div>
      </footer>
  </article>
  
  
  

      
  
  
  <article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-CN">
    <link itemprop="mainEntityOfPage" href="https://wangkejie.gitee.io/blogwebpage/flutter/index.html">

    <span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
      <meta itemprop="image" content="/blogwebpage/images/avatar.gif">
      <meta itemprop="name" content="Jack Wang">
      <meta itemprop="description" content="书山有路勤为径，学海无涯苦作舟！">
    </span>

    <span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
      <meta itemprop="name" content="王科杰">
    </span>
      <header class="post-header">
        <h2 class="post-title" itemprop="name headline">
          
            <a href="/blogwebpage/flutter/index.html" class="post-title-link" itemprop="url">Flutter</a>
        </h2>

        <div class="post-meta">
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-calendar"></i>
              </span>
              <span class="post-meta-item-text">发表于</span>

              <time title="创建时间：2019-07-31 00:00:00" itemprop="dateCreated datePublished" datetime="2019-07-31T00:00:00+08:00">2019-07-31</time>
            </span>
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-folder"></i>
              </span>
              <span class="post-meta-item-text">分类于</span>
                <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
                  <a href="/blogwebpage/categories/flutter/" itemprop="url" rel="index"><span itemprop="name">flutter</span></a>
                </span>
            </span>

          

        </div>
      </header>

    
    
    
    <div class="post-body" itemprop="articleBody">

      
          <h1 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h1><p>Flutter已经面世这么长时间了，不抽空学习一下，实在是对不起自己。也是由于前天面试被问到Flutter的一些东西，一脸懵逼，真不是一个合格的iOS开发猿！！！</p>
<p>分享一下学习经验和心得，纪录一下学习过程的疑问。</p>
<p>官网学习，手敲练习<span class="exturl" data-url="aHR0cHM6Ly9naXRodWIuY29tL0phY2stVmluZy9mbHV0dGVyLXN0dWR5">demo源码<i class="fa fa-external-link-alt"></i></span></p>
<h2 id="学习之前我有几个问题问自己"><a href="#学习之前我有几个问题问自己" class="headerlink" title="学习之前我有几个问题问自己"></a>学习之前我有几个问题问自己</h2><ul>
<li>为什么大家都说Flutter比RN和Weex流畅？ </li>
<li>和RN、Weex实现原理对比, Flutter的实现原理是什么？</li>
<li>怎么和Native通讯？</li>
</ul>
          <!--noindex-->
            <div class="post-button">
              <a class="btn" href="/blogwebpage/flutter/index.html#more" rel="contents">
                阅读全文 &raquo;
              </a>
            </div>
          <!--/noindex-->
        
      
    </div>

    
    
    
      <footer class="post-footer">
        <div class="post-eof"></div>
      </footer>
  </article>
  
  
  

      
  
  
  <article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-CN">
    <link itemprop="mainEntityOfPage" href="https://wangkejie.gitee.io/blogwebpage/llvm/lldb.html">

    <span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
      <meta itemprop="image" content="/blogwebpage/images/avatar.gif">
      <meta itemprop="name" content="Jack Wang">
      <meta itemprop="description" content="书山有路勤为径，学海无涯苦作舟！">
    </span>

    <span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
      <meta itemprop="name" content="王科杰">
    </span>
      <header class="post-header">
        <h2 class="post-title" itemprop="name headline">
          
            <a href="/blogwebpage/llvm/lldb.html" class="post-title-link" itemprop="url">LLDB</a>
        </h2>

        <div class="post-meta">
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-calendar"></i>
              </span>
              <span class="post-meta-item-text">发表于</span>

              <time title="创建时间：2019-07-31 00:00:00" itemprop="dateCreated datePublished" datetime="2019-07-31T00:00:00+08:00">2019-07-31</time>
            </span>
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-folder"></i>
              </span>
              <span class="post-meta-item-text">分类于</span>
                <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
                  <a href="/blogwebpage/categories/LLVM/" itemprop="url" rel="index"><span itemprop="name">LLVM</span></a>
                </span>
                  ，
                <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
                  <a href="/blogwebpage/categories/LLVM/LLDB/" itemprop="url" rel="index"><span itemprop="name">LLDB</span></a>
                </span>
            </span>

          

        </div>
      </header>

    
    
    
    <div class="post-body" itemprop="articleBody">

      
          <p><span class="exturl" data-url="aHR0cHM6Ly9sbGRiLmxsdm0ub3JnLw==">LLDB官方文档地址<i class="fa fa-external-link-alt"></i></span></p>
<h1 id="LLDB调试器"><a href="#LLDB调试器" class="headerlink" title="LLDB调试器"></a>LLDB调试器</h1><p>LLVM源代码树，并在lldb 子目录中找到源代码：</p>
<blockquote>
<p>git clone <span class="exturl" data-url="aHR0cHM6Ly9naXRodWIuY29tL2xsdm0vbGx2bS1wcm9qZWN0LmdpdA==">https://github.com/llvm/llvm-project.git<i class="fa fa-external-link-alt"></i></span><br>请注意，LLDB通常使用CMake和Ninja从top-of-trunk构建。另外它构建：</p>
</blockquote>
<ul>
<li>在macOS上生成Xcode项目</li>
<li>在Linux和FreeBSD上使用clang和libstdc ++ / libc ++</li>
<li>在NetBSD上使用GCC / clang和libstdc ++ / libc ++</li>
<li>在Windows上生成VS 2017或更高版本的项目</li>
</ul>
<p>先说大话：</p>
<ul>
<li>构建库以包含在IDE，命令行工具和其他分析工具中</li>
<li>高性能和高效的内存使用</li>
<li>可扩展：Python可编写脚本并使用插件架构</li>
<li>在有意义的地方重用现有的编译器技术</li>
<li>出色的多线程调试支持</li>
<li>对C，Objective-C和C ++的大力支持</li>
<li>可重定向以支持多个平台</li>
<li>为调试器研究和其他创新提供基础</li>
</ul>
<p>LDB支持各种基本调试功能，如读取DWARF，支持步骤，下一步，完成，回溯等。一些更感兴趣的位是：</p>
<ul>
<li>用于可移植性和可扩展性的插件架构：<ul>
<li>可执行文件格式的目标文件解析器。目前支持包括Mach-O（32位和64位）和ELF（32位）。</li>
<li>对象容器解析器，用于提取文件中包含的对象文件。支持目前包括通用Mach-O文件和BSD档案。</li>
<li>调试符号文件解析器以从对象文件中逐步提取调试信息。支持目前包括DWARF和Mach-O符号表。</li>
<li>符号供应商插件从可执行对象的各种不同源收集数据。</li>
<li>每个体系结构的反汇编插件。支持目前包括用于i386，x86-64，ARM / Thumb和PPC64le的LLVM反汇编程序</li>
<li>调试器插件实现调试所需的主机和目标特定功能。</li>
</ul>
</li>
<li>SWIG生成的脚本桥接允许Python访问和控制调试器库的公共API。</li>
<li>远程协议服务器debugserver在i386和x86-64上实现macOS调试。</li>
<li>命令行调试器 - lldb可执行文件本身。</li>
<li>库的框架API。</li>
</ul>
<h2 id="编译器集成的好处"><a href="#编译器集成的好处" class="headerlink" title="编译器集成的好处"></a>编译器集成的好处</h2><p>LLDB目前将调试信息转换为clang类型，以便它可以利用clang编译器基础结构。这允许LLDB在表达式中支持最新的C，C ++，Objective-C和Objective-C ++语言特性和运行时，而无需重新实现任何此功能。它还利用编译器在对表达式进行函数调用时，在反汇编指令和提取指令细节等时处理所有ABI细节。</p>
<p>主要好处包括：</p>
<ul>
<li>最新的C，C ++，Objective-C语言支持</li>
<li>可以声明局部变量和类型的多行表达式</li>
<li>支持时使用JIT表达式</li>
<li>当不能使用JIT时，评估表达式中间表示（IR）</li>
</ul>
<h1 id="使用"><a href="#使用" class="headerlink" title="使用"></a>使用</h1><h2 id="命令结构"><a href="#命令结构" class="headerlink" title="命令结构"></a>命令结构</h2><blockquote>
<p><code>&lt;noun&gt; &lt;verb&gt; [-options [option-value]] [argument [argument...]]</code></p>
</blockquote>
<p>选项可以放在命令行的任何位置，但是如果参数以“ - ”开头，那么你必须告诉lldb你已经完成了当前命令的选项，方法是添加一个选项终止：“ - ”所以例如如果你想启动一个进程并给“进程启动”命令“-stop-at-entry”选项，但是你想要启动你要启动的进程并使用参数“-program_arg value”，你会输入：</p>
<ul>
<li><p>(lldb) process launch –stop-at-entry – -program_arg value</p>
</li>
<li><p>要在LLDB中设置相同的文件和换行符，您可以输入以下任一项：<br>(lldb) breakpoint set –file foo.c –line 12<br>(lldb) breakpoint set -f foo.c -l 12</p>
</li>
<li><p>您可以多次使用-name选项在一组函数上创建断点。<br>(lldb) breakpoint set –name foo<br>(lldb) breakpoint set -n foo<br>(lldb) breakpoint set –name foo –name bar</p>
</li>
<li><p>要在名为foo的所有C ++方法上设置断点，您可以输入以下任一项：<br>(lldb) breakpoint set –method foo<br>(lldb) breakpoint set -M foo</p>
</li>
<li><p>设置一个名为alignLeftEdges的断点Objective-C选择器：<br>(lldb) breakpoint set –selector alignLeftEdges:<br>(lldb) breakpoint set -S alignLeftEdges:</p>
</li>
<li><p>您可以使用“-shlib &lt;path&gt;”（简称“-s &lt;path&gt;”）将任何断点限制为特定的可执行映像：<br>(lldb) breakpoint set –shlib foo.dylib –name foo<br>(lldb) breakpoint set -s foo.dylib -n foo</p>
</li>
<li><p>lldb命令解释器对命令名进行最短的唯一字符串匹配，因此以下两个命令都将执行相同的命令：<br>(lldb) breakpoint set -n “-[SKTGraphicView alignLeftEdges:]”<br>(lldb) br s -n “-[SKTGraphicView alignLeftEdges:]”</p>
</li>
</ul>
<h2 id="设置观察点"><a href="#设置观察点" class="headerlink" title="设置观察点"></a>设置观察点</h2><p>除断点外，您还可以使用help watchpoint查看监视点操作的所有命令。例如，我们可能会执行以下操作来查看名为“global”的变量进行写入操作，但只有在条件“（global == 5）”为真时才会停止：</p>
<p>(lldb) watch set var global<br>(lldb) watch modify -c ‘(global==5)’<br>(lldb) watch list<br>(lldb) about to write to ‘global’…</p>
<h2 id="启动或附加到您的程序"><a href="#启动或附加到您的程序" class="headerlink" title="启动或附加到您的程序"></a>启动或附加到您的程序</h2><ul>
<li><p>要在lldb中启动程序，我们使用“process launch”命令或其内置别名之一：<br>(lldb) process launch<br>(lldb) run<br>(lldb) r</p>
</li>
<li><p>您还可以按进程ID或进程名称附加到进程。当按名称附加到进程时，lldb还支持“-waitfor”选项，该选项等待显示该名称的下一个进程，并附加到该进程<br>(lldb) process attach –pid 123<br>(lldb) process attach –name Sketch<br>(lldb) process attach –name Sketch –waitfor</p>
</li>
<li><p>启动或附加到进程后，您的进程可能会在某处停止：</p>
<figure class="highlight routeros"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">(lldb) process attach -p 12345</span><br><span class="line">Process 46915 Attaching</span><br><span class="line">Process 46915 Stopped</span><br><span class="line">1 of 3 threads stopped with reasons:</span><br><span class="line">* thread #1: tid = 0x2c03, 0x00007fff85cac76a, where = libSystem.B.dylib`__getdirentries64 + 10, stop reason = signal = SIGSTOP,<span class="built_in"> queue </span>= com.apple.main-thread</span><br></pre></td></tr></table></figure></li>
</ul>
<h2 id="控制你的程序"><a href="#控制你的程序" class="headerlink" title="控制你的程序"></a>控制你的程序</h2><ul>
<li><p>启动后，我们可以继续，直到我们达到断点。进程控制的原始命令都存在于“thread”命令下：<br>(lldb) thread continue<br>Resuming thread 0x2c03 in process 46915<br>Resuming process 46915<br>(lldb)</p>
</li>
<li><p>步进命令<br>(lldb) thread step-in    // The same as gdb’s “step” or “s”<br>(lldb) thread step-over  // The same as gdb’s “next” or “n”<br>(lldb) thread step-out   // The same as gdb’s “finish” or “f”</p>
</li>
<li><p>逐步指令版本：<br>(lldb) thread step-inst       // The same as gdb’s “stepi” / “si”<br>(lldb) thread step-over-inst  // The same as gdb’s “nexti” / “ni”</p>
</li>
<li><p>最后，lldb运行直到行或帧退出步进模式：<br>(lldb) thread until 100</p>
</li>
</ul>
<h2 id="检查堆栈帧状态"><a href="#检查堆栈帧状态" class="headerlink" title="检查堆栈帧状态"></a>检查堆栈帧状态</h2><ul>
<li>检查框架参数和局部变量的最方便方法是使用“frame variable”命令：<br>(lldb) frame variable</li>
</ul>
<h1 id="不想写了，用到的时候，写一些用到的东西吧，学习的话，大家去看官方文档吧！！！"><a href="#不想写了，用到的时候，写一些用到的东西吧，学习的话，大家去看官方文档吧！！！" class="headerlink" title="不想写了，用到的时候，写一些用到的东西吧，学习的话，大家去看官方文档吧！！！"></a>不想写了，用到的时候，写一些用到的东西吧，学习的话，大家去看官方文档吧！！！</h1>
      
    </div>

    
    
    
      <footer class="post-footer">
        <div class="post-eof"></div>
      </footer>
  </article>
  
  
  

      
  
  
  <article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-CN">
    <link itemprop="mainEntityOfPage" href="https://wangkejie.gitee.io/blogwebpage/iOS/crashreport/crashanalysis.html">

    <span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
      <meta itemprop="image" content="/blogwebpage/images/avatar.gif">
      <meta itemprop="name" content="Jack Wang">
      <meta itemprop="description" content="书山有路勤为径，学海无涯苦作舟！">
    </span>

    <span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
      <meta itemprop="name" content="王科杰">
    </span>
      <header class="post-header">
        <h2 class="post-title" itemprop="name headline">
          
            <a href="/blogwebpage/iOS/crashreport/crashanalysis.html" class="post-title-link" itemprop="url">iOS程序崩溃抓获与分析</a>
        </h2>

        <div class="post-meta">
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-calendar"></i>
              </span>
              <span class="post-meta-item-text">发表于</span>

              <time title="创建时间：2019-07-15 11:26:39" itemprop="dateCreated datePublished" datetime="2019-07-15T11:26:39+08:00">2019-07-15</time>
            </span>
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-folder"></i>
              </span>
              <span class="post-meta-item-text">分类于</span>
                <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
                  <a href="/blogwebpage/categories/iOS/" itemprop="url" rel="index"><span itemprop="name">iOS</span></a>
                </span>
                  ，
                <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
                  <a href="/blogwebpage/categories/iOS/iOS-Crash-Grab/" itemprop="url" rel="index"><span itemprop="name">iOS Crash Grab</span></a>
                </span>
            </span>

          

        </div>
      </header>

    
    
    
    <div class="post-body" itemprop="articleBody">

      
          <h1 id="iOS-App程序崩溃的抓取与分析"><a href="#iOS-App程序崩溃的抓取与分析" class="headerlink" title="iOS App程序崩溃的抓取与分析"></a>iOS App程序崩溃的抓取与分析</h1><blockquote>
<p>备用: <span class="exturl" data-url="aHR0cHM6Ly9vcGVuc291cmNlLmFwcGxlLmNvbS90YXJiYWxscy94bnUv">xun开源代码地址<i class="fa fa-external-link-alt"></i></span></p>
</blockquote>
<ol>
<li>Mach异常捕获方式<ul>
<li>mach_port_allocate 创建一场端口</li>
<li>mach_port_insert_right 申请 set_exception_ports 的权限</li>
<li>xxx_set_exception_ports 设置异常端口</li>
<li>循环等待异常消息</li>
</ul>
</li>
<li>Unix 信号方式 signal(SIGSEGV, signalHandler)<ul>
<li>除了OC层面的异常捕捉之外，很多内存错误、访问错误的地址产生的crash则需要利用unix标准的signal机制，注册SIGABRT, SIGBUS, SIGSEGV等信号发生时的处理函数。该函数中我们可以输出栈信息，版本信息等其他一切我们所想要的。</li>
</ul>
</li>
<li>Mach异常 + Unix信号方式<ul>
<li>某个NSException导致程序Crash的，只有拿到这个NSException，获取它的reason，name，callStackSymbols信息才能确定出问题的程序位置。</li>
<li>方法很简单，可通过注册NSUncaughtExceptionHandler捕获异常信息<figure class="highlight csharp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">static</span> <span class="keyword">void</span> <span class="title">my_uncaught_exception_handler</span> (<span class="params">NSException *exception</span>)</span> &#123;</span><br><span class="line">    <span class="comment">//这里可以取到 NSException 信息</span></span><br><span class="line">&#125;</span><br><span class="line">NSSetUncaughtExceptionHandler(&amp;my_uncaught_exception_handler);</span><br><span class="line"></span><br></pre></td></tr></table></figure></li>
</ul>
</li>
</ol>
<h2 id="多个-Crash-日志收集服务共存"><a href="#多个-Crash-日志收集服务共存" class="headerlink" title="多个 Crash 日志收集服务共存"></a>多个 Crash 日志收集服务共存</h2><ul>
<li>拒绝传递 UncaughtExceptionHandler</li>
<li>开发测试阶段，可以利用 fishhook 框架去hookNSSetUncaughtExceptionHandler方法,这样就可以清晰的看到handler的传递流程断在哪里，快速定位污染环境者。</li>
<li>Mach异常端口换出+信号处理Handler覆盖</li>
<li>影响系统崩溃日志准确性<ul>
<li>若程序因NSException而Crash，系统日志中的Last Exception Backtrace信息是完整准确的，不会受应用层的胡来而影响，可作为排查问题的参考线索。</li>
</ul>
</li>
</ul>
<h2 id="概述"><a href="#概述" class="headerlink" title="概述"></a>概述</h2><p>Mach: 微内核，负责操作系统中基本职责：进程和线程抽象、虚拟内存管理、任务调度、进程间通信和消息传递机制。</p>
<p>大家熟知的NSSetUncaughtExceptionHandler() + signal() / sigaction()的方式收集Crash,但是stack overflow并不能被此方法扑捉到;</p>
<p>通常我们所说的异常，一般是有处理器陷阱引发的,通用的Mach异常处理程序exception_triage()，负责将异常转换成Mach 消息。exception_triage()通过调用exception_deliver()尝试把异常投递到thread、task最后是host。首先尝试将异常抛给thread端口，然后尝试抛给task端口，最后再抛给host端口(默认端口)，如果没有一个端口返回KERN_SUCCESS，那么任务就会被终止。</p>
<blockquote>
<p>代码太多，不再贴了，自行下载源码，找到 osfmk/kern/exception.c 文件。 里面有<code>exception_triage()和exception_deliver()函数</code>。关于<code>Exception</code>的相关定义，可以在<code>osfmk/mach/exception_types.h</code>里面查看。下面只贴伪代码</p>
</blockquote>
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br></pre></td><td class="code"><pre><span class="line"></span><br><span class="line"><span class="comment">// 位于 osfmk/kern/exception.c</span></span><br><span class="line"><span class="keyword">kern_return_t</span></span><br><span class="line">xception_triage(</span><br><span class="line">    <span class="keyword">exception_type_t</span> exception,</span><br><span class="line">    <span class="keyword">mach_exception_data_t</span> code,</span><br><span class="line">    <span class="keyword">mach_msg_type_number_t</span> codeCnt</span><br><span class="line">)</span><br><span class="line">&#123;</span><br><span class="line">    <span class="keyword">thread_t</span> thread;</span><br><span class="line">    <span class="keyword">task_t</span> task;</span><br><span class="line">    <span class="keyword">host_priv_t</span> host_priv;</span><br><span class="line">    <span class="keyword">lck_mtx_t</span> *mutex;</span><br><span class="line">    <span class="keyword">kern_return_t</span> kr = KERN_FAILURE;</span><br><span class="line">    assert(exception != EXC_RPC_ALERT);</span><br><span class="line">    <span class="keyword">if</span> (panic_on_exception_triage) &#123;</span><br><span class="line">        panic(<span class="string">&quot;called exception_triage when it was forbidden by the boot environment&quot;</span>);</span><br><span class="line">    &#125;</span><br><span class="line">    thread = current_thread();</span><br><span class="line">        </span><br><span class="line">    <span class="comment">// ================ 分别尝试把异常投递到thread、task最后是host。================</span></span><br><span class="line">    <span class="comment">/*</span></span><br><span class="line"><span class="comment">     * Try to raise the exception at the activation level.</span></span><br><span class="line"><span class="comment">     */</span></span><br><span class="line">    mutex = &amp;thread-&gt;mutex;</span><br><span class="line">    <span class="keyword">if</span> (KERN_SUCCESS == check_exc_receiver_dependency(exception, thread-&gt;exc_actions, mutex))</span><br><span class="line">    &#123;</span><br><span class="line">        kr = exception_deliver(thread, exception, code, codeCnt, thread-&gt;exc_actions, mutex);</span><br><span class="line">        <span class="keyword">if</span> (kr == KERN_SUCCESS || kr == MACH_RCV_PORT_DIED)</span><br><span class="line">            <span class="keyword">goto</span> out;</span><br><span class="line">    &#125;</span><br><span class="line">    <span class="comment">/*</span></span><br><span class="line"><span class="comment">     * Maybe the task level will handle it.</span></span><br><span class="line"><span class="comment">     */</span></span><br><span class="line">    task = current_task();</span><br><span class="line">    mutex = &amp;task-&gt;lock;</span><br><span class="line">    <span class="keyword">if</span> (KERN_SUCCESS == check_exc_receiver_dependency(exception, task-&gt;exc_actions, mutex))</span><br><span class="line">    &#123;</span><br><span class="line">        kr = exception_deliver(thread, exception, code, codeCnt, task-&gt;exc_actions, mutex);</span><br><span class="line">        <span class="keyword">if</span> (kr == KERN_SUCCESS || kr == MACH_RCV_PORT_DIED)</span><br><span class="line">            <span class="keyword">goto</span> out;</span><br><span class="line">    &#125;</span><br><span class="line"></span><br><span class="line">    <span class="comment">/*</span></span><br><span class="line"><span class="comment">     * How about at the host level?</span></span><br><span class="line"><span class="comment">     */</span></span><br><span class="line">    host_priv = host_priv_self();</span><br><span class="line">    mutex = &amp;host_priv-&gt;lock;</span><br><span class="line"></span><br><span class="line">    <span class="keyword">if</span> (KERN_SUCCESS == check_exc_receiver_dependency(exception, host_priv-&gt;exc_actions, mutex))</span><br><span class="line">    &#123;</span><br><span class="line">        kr = exception_deliver(thread, exception, code, codeCnt, host_priv-&gt;exc_actions, mutex);</span><br><span class="line">        <span class="keyword">if</span> (kr == KERN_SUCCESS || kr == MACH_RCV_PORT_DIED)</span><br><span class="line">            <span class="keyword">goto</span> out;</span><br><span class="line">    &#125;</span><br><span class="line"></span><br><span class="line">out:</span><br><span class="line">    <span class="keyword">if</span> ((exception != EXC_CRASH) &amp;&amp; (exception != EXC_RESOURCE) &amp;&amp;</span><br><span class="line">        (exception != EXC_GUARD) &amp;&amp; (exception != EXC_CORPSE_NOTIFY))</span><br><span class="line">        thread_exception_return();</span><br><span class="line">    <span class="keyword">return</span> kr;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>

<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br><span class="line">63</span><br><span class="line">64</span><br><span class="line">65</span><br><span class="line">66</span><br><span class="line">67</span><br><span class="line">68</span><br><span class="line">69</span><br><span class="line">70</span><br><span class="line">71</span><br><span class="line">72</span><br><span class="line">73</span><br><span class="line">74</span><br><span class="line">75</span><br><span class="line">76</span><br><span class="line">77</span><br><span class="line">78</span><br><span class="line">79</span><br><span class="line">80</span><br><span class="line">81</span><br><span class="line">82</span><br><span class="line">83</span><br><span class="line">84</span><br><span class="line">85</span><br><span class="line">86</span><br><span class="line">87</span><br><span class="line">88</span><br><span class="line">89</span><br><span class="line">90</span><br><span class="line">91</span><br><span class="line">92</span><br><span class="line">93</span><br><span class="line">94</span><br><span class="line">95</span><br><span class="line">96</span><br><span class="line">97</span><br><span class="line">98</span><br><span class="line">99</span><br><span class="line">100</span><br><span class="line">101</span><br><span class="line">102</span><br><span class="line">103</span><br><span class="line">104</span><br><span class="line">105</span><br><span class="line">106</span><br><span class="line">107</span><br><span class="line">108</span><br><span class="line">109</span><br><span class="line">110</span><br><span class="line">111</span><br></pre></td><td class="code"><pre><span class="line"></span><br><span class="line"><span class="comment">// 位于 osfmk/kern/exception.c</span></span><br><span class="line"><span class="keyword">kern_return_t</span></span><br><span class="line">exception_deliver(</span><br><span class="line">    <span class="keyword">thread_t</span>        thread,</span><br><span class="line">    <span class="keyword">exception_type_t</span>    exception,</span><br><span class="line">    <span class="keyword">mach_exception_data_t</span>   code,</span><br><span class="line">    <span class="keyword">mach_msg_type_number_t</span>  codeCnt,</span><br><span class="line">    struct exception_action *excp,</span><br><span class="line">    <span class="keyword">lck_mtx_t</span>           *mutex)</span><br><span class="line">&#123;</span><br><span class="line">    ...  <span class="comment">// 省略部分代码</span></span><br><span class="line"></span><br><span class="line">    <span class="keyword">switch</span> (behavior) &#123;</span><br><span class="line">        <span class="keyword">case</span> EXCEPTION_STATE: &#123;</span><br><span class="line">            <span class="keyword">mach_msg_type_number_t</span> state_cnt;</span><br><span class="line">            <span class="keyword">thread_state_data_t</span> state;</span><br><span class="line">            </span><br><span class="line">            c_thr_exc_raise_state++;</span><br><span class="line">            state_cnt = _MachineStateCount[flavor];</span><br><span class="line">            kr = thread_getstatus(thread, flavor,</span><br><span class="line">                                  (<span class="keyword">thread_state_t</span>)state,</span><br><span class="line">                                  &amp;state_cnt);</span><br><span class="line">            <span class="keyword">if</span> (kr == KERN_SUCCESS) &#123;</span><br><span class="line">                <span class="keyword">if</span> (code64) &#123;</span><br><span class="line">                    kr = mach_exception_raise_state(exc_port,</span><br><span class="line">                                                    exception,</span><br><span class="line">                                                    code,</span><br><span class="line">                                                    codeCnt,</span><br><span class="line">                                                    &amp;flavor,</span><br><span class="line">                                                    state, state_cnt,</span><br><span class="line">                                                    state, &amp;state_cnt);</span><br><span class="line">                &#125; <span class="keyword">else</span> &#123;</span><br><span class="line">                    kr = exception_raise_state(exc_port, exception,</span><br><span class="line">                                               small_code,</span><br><span class="line">                                               codeCnt,</span><br><span class="line">                                               &amp;flavor,</span><br><span class="line">                                               state, state_cnt,</span><br><span class="line">                                               state, &amp;state_cnt);</span><br><span class="line">                &#125;</span><br><span class="line">                <span class="keyword">if</span> (kr == MACH_MSG_SUCCESS &amp;&amp; exception != EXC_CORPSE_NOTIFY)</span><br><span class="line">                    kr = thread_setstatus(thread, flavor,</span><br><span class="line">                                          (<span class="keyword">thread_state_t</span>)state,</span><br><span class="line">                                          state_cnt);</span><br><span class="line">            &#125;</span><br><span class="line">            <span class="keyword">return</span> kr;</span><br><span class="line">        &#125;</span><br><span class="line">            </span><br><span class="line">        <span class="keyword">case</span> EXCEPTION_DEFAULT:</span><br><span class="line">            c_thr_exc_raise++;</span><br><span class="line">            <span class="keyword">if</span> (code64) &#123;</span><br><span class="line">                kr = mach_exception_raise(exc_port,</span><br><span class="line">                                          retrieve_thread_self_fast(thread),</span><br><span class="line">                                          retrieve_task_self_fast(thread-&gt;task),</span><br><span class="line">                                          exception,</span><br><span class="line">                                          code,</span><br><span class="line">                                          codeCnt);</span><br><span class="line">            &#125; <span class="keyword">else</span> &#123;</span><br><span class="line">                kr = exception_raise(exc_port,</span><br><span class="line">                                     retrieve_thread_self_fast(thread),</span><br><span class="line">                                     retrieve_task_self_fast(thread-&gt;task),</span><br><span class="line">                                     exception,</span><br><span class="line">                                     small_code, </span><br><span class="line">                                     codeCnt);</span><br><span class="line">            &#125;</span><br><span class="line">            <span class="keyword">return</span> kr;</span><br><span class="line">            </span><br><span class="line">        <span class="keyword">case</span> EXCEPTION_STATE_IDENTITY: &#123;</span><br><span class="line">            <span class="keyword">mach_msg_type_number_t</span> state_cnt;</span><br><span class="line">            <span class="keyword">thread_state_data_t</span> state;</span><br><span class="line">            </span><br><span class="line">            c_thr_exc_raise_state_id++;</span><br><span class="line">            state_cnt = _MachineStateCount[flavor];</span><br><span class="line">            kr = thread_getstatus(thread, flavor,</span><br><span class="line">                                  (<span class="keyword">thread_state_t</span>)state,</span><br><span class="line">                                  &amp;state_cnt);</span><br><span class="line">            <span class="keyword">if</span> (kr == KERN_SUCCESS) &#123;</span><br><span class="line">                <span class="keyword">if</span> (code64) &#123;</span><br><span class="line">                    kr = mach_exception_raise_state_identity(exc_port,</span><br><span class="line">                                                             retrieve_thread_self_fast(thread),</span><br><span class="line">                                                             retrieve_task_self_fast(thread-&gt;task),</span><br><span class="line">                                                             exception,</span><br><span class="line">                                                             code, </span><br><span class="line">                                                             codeCnt,</span><br><span class="line">                                                             &amp;flavor,</span><br><span class="line">                                                             state, state_cnt,</span><br><span class="line">                                                             state, &amp;state_cnt);</span><br><span class="line">                &#125; <span class="keyword">else</span> &#123;</span><br><span class="line">                    kr = exception_raise_state_identity(exc_port,</span><br><span class="line">                                                        retrieve_thread_self_fast(thread),</span><br><span class="line">                                                        retrieve_task_self_fast(thread-&gt;task),</span><br><span class="line">                                                        exception,</span><br><span class="line">                                                        small_code, </span><br><span class="line">                                                        codeCnt,</span><br><span class="line">                                                        &amp;flavor,</span><br><span class="line">                                                        state, state_cnt,</span><br><span class="line">                                                        state, &amp;state_cnt);</span><br><span class="line">                &#125;</span><br><span class="line">                <span class="keyword">if</span> (kr == MACH_MSG_SUCCESS &amp;&amp; exception != EXC_CORPSE_NOTIFY)</span><br><span class="line">                    kr = thread_setstatus(thread, flavor,</span><br><span class="line">                                          (<span class="keyword">thread_state_t</span>)state,</span><br><span class="line">                                          state_cnt);</span><br><span class="line">            &#125;</span><br><span class="line">            <span class="keyword">return</span> kr;</span><br><span class="line">        &#125;</span><br><span class="line">            </span><br><span class="line">        <span class="keyword">default</span>:</span><br><span class="line">            panic (<span class="string">&quot;bad exception behavior!&quot;</span>);</span><br><span class="line">            <span class="keyword">return</span> KERN_FAILURE; </span><br><span class="line">    &#125;<span class="comment">/* switch */</span></span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>


<p>当第一个BSD进程调用bsdinit_task()函数(<code>源码位于bsd/kern/bsd_init.c</code>)启动时，这函数还调用了ux_handler_init()函数(<code>位于bsd/uxkern/ux_exception.c</code>)设置了一个Mach内核线程跑ux_handler()的。</p>
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br></pre></td><td class="code"><pre><span class="line"></span><br><span class="line"><span class="comment">// 位于bsd/kern/bsd_init.c</span></span><br><span class="line"><span class="comment">/* Called with kernel funnel held */</span></span><br><span class="line"><span class="keyword">void</span></span><br><span class="line">bsdinit_task(<span class="keyword">void</span>)</span><br><span class="line">&#123;</span><br><span class="line"><span class="comment">//  ...省略</span></span><br><span class="line"></span><br><span class="line">  ux_handler_init(); <span class="comment">// 初始化handler</span></span><br><span class="line"></span><br><span class="line">  <span class="comment">// 设置port</span></span><br><span class="line">  thread = current_thread();</span><br><span class="line">  (<span class="keyword">void</span>) host_set_exception_ports(host_priv_self(),</span><br><span class="line">     EXC_MASK_ALL &amp; ~(EXC_MASK_RPC_ALERT),<span class="comment">//pilotfish (shark) needs this port</span></span><br><span class="line">     (<span class="keyword">mach_port_t</span>) ux_exception_port,</span><br><span class="line">     EXCEPTION_DEFAULT| MACH_EXCEPTION_CODES,</span><br><span class="line">     <span class="number">0</span>);</span><br><span class="line"></span><br><span class="line">  ut = (<span class="keyword">uthread_t</span>)get_bsdthread_info(thread);</span><br><span class="line"></span><br><span class="line">  bsd_init_task = get_threadtask(thread);</span><br><span class="line">  init_task_failure_data[<span class="number">0</span>] = <span class="number">0</span>;</span><br><span class="line"></span><br><span class="line"><span class="meta">#<span class="meta-keyword">if</span> CONFIG_MACF</span></span><br><span class="line">  mac_cred_label_associate_user(p-&gt;p_ucred);</span><br><span class="line">  mac_task_label_update_cred (p-&gt;p_ucred, (struct task *) p-&gt;task);</span><br><span class="line"><span class="meta">#<span class="meta-keyword">endif</span></span></span><br><span class="line">  load_init_program(p);</span><br><span class="line">  lock_trace = <span class="number">1</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>



<p>每一个thread、task及host自身都有一个异常端口数组，通过调用xxx_set_exception_ports()（xxx为thread、task或host）可以设置这些异常端口。 xxx_set_exception_ports()第四个参数为exception_behavior_t behavior，这将会使用到与行为相匹配的实现（exc.defs 或  mach_exc.defs）。<br>各种行为都在host层被catch_[mach]_exception_xxx处理，64位的对应的是有mach函数(可在/bsd/uxkern/ux_exception.c查看)。<br>这些函数通过调用ux_exception()将异常转换为对应的UNIX信号，并通过threadsignal()将信号投递到出错线程。</p>
<p>所以，如果异常是栈溢出，那么signal是SIGSEGV而不是SIGBUS；如果进程退出了或者线程/进程未准备好处理signal，所注册的signal()是无法接收信号的。</p>
<img src="/blogwebpage/images/iOS/exception_handler.png" class="" title="exception_handler">

<p>把Mach exception 和 UNIX signal 的转换制表后，如下</p>
<table>
<thead>
<tr>
<th>exception type</th>
<th>signal</th>
</tr>
</thead>
<tbody><tr>
<td>EXC_BAD_ACCESS</td>
<td>1、SIGSEGV (KERN_INVALID_ADDRESS)  <br>  2、SIGBUS(其它)</td>
</tr>
<tr>
<td>EXC_BAD_INSTRUCTION</td>
<td>SIGILL</td>
</tr>
<tr>
<td>EXC_ARITHMETIC</td>
<td>SIGFPE</td>
</tr>
<tr>
<td>EXC_EMULATION</td>
<td>SIGEMT</td>
</tr>
<tr>
<td>EXC_SOFTWARE</td>
<td>1、SIGSYS(EXC_UNIX_BAD_SYSCALL) <br> 2、SIGPIPE(EXC_UNIX_BAD_PIPE) <br> 3、SIGABRT(EXC_UNIX_ABORT) <br> 4、SIGKILL(EXC_SOFT_SIGNAL)</td>
</tr>
<tr>
<td>EXC_BREAKPOINT</td>
<td>SIGTRAP ()</td>
</tr>
</tbody></table>
<h2 id="实战"><a href="#实战" class="headerlink" title="实战"></a>实战</h2><p>在Mach中，异常是通过内核中的主要设施-消息传递机制-进行处理的。一个异常与一条消息并无差别，由出错的线程或任务（通过 msg_send()）发送，并通过一个处理程（通过 msg_recv()）接收。<br>由于Mach的异常以消息机制处理而不是通过函数调用，exception messages可以被转发到先前注册的Mach exception处理程序。这意味着你可以插入一个exception处理程序，而不干扰现有的无论是调试器或Apple’s crash reporter。可以使用mach_msg() // flag MACH_SEND_MSG发送原始消息到以前注册的处理程序的Mach端口，将消息转发到一个现有的处理程序。</p>
<figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br><span class="line">63</span><br><span class="line">64</span><br><span class="line">65</span><br><span class="line">66</span><br><span class="line">67</span><br><span class="line">68</span><br><span class="line">69</span><br><span class="line">70</span><br><span class="line">71</span><br><span class="line">72</span><br><span class="line">73</span><br><span class="line">74</span><br><span class="line">75</span><br><span class="line">76</span><br><span class="line">77</span><br><span class="line">78</span><br><span class="line">79</span><br><span class="line">80</span><br><span class="line">81</span><br><span class="line">82</span><br><span class="line">83</span><br><span class="line">84</span><br><span class="line">85</span><br><span class="line">86</span><br><span class="line">87</span><br><span class="line">88</span><br><span class="line">89</span><br><span class="line">90</span><br><span class="line">91</span><br><span class="line">92</span><br><span class="line">93</span><br><span class="line">94</span><br><span class="line">95</span><br><span class="line">96</span><br><span class="line">97</span><br><span class="line">98</span><br><span class="line">99</span><br><span class="line">100</span><br><span class="line">101</span><br><span class="line">102</span><br><span class="line">103</span><br><span class="line">104</span><br><span class="line">105</span><br><span class="line">106</span><br><span class="line">107</span><br><span class="line">108</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">catchMACHExceptions</span><span class="params">()</span> </span>&#123;</span><br><span class="line">    </span><br><span class="line">    <span class="keyword">kern_return_t</span> rc = <span class="number">0</span>;</span><br><span class="line">    <span class="keyword">exception_mask_t</span> excMask = EXC_MASK_BAD_ACCESS |</span><br><span class="line">    EXC_MASK_BAD_INSTRUCTION |</span><br><span class="line">    EXC_MASK_ARITHMETIC |</span><br><span class="line">    EXC_MASK_SOFTWARE |</span><br><span class="line">    EXC_MASK_BREAKPOINT;</span><br><span class="line">    </span><br><span class="line">    rc = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &amp;myExceptionPort);</span><br><span class="line">    <span class="keyword">if</span> (rc != KERN_SUCCESS) &#123;</span><br><span class="line">        <span class="built_in">fprintf</span>(<span class="built_in">stderr</span>, <span class="string">&quot;-------&gt;Fail to allocate exception port\\\\\\\\n&quot;</span>);</span><br><span class="line">        <span class="keyword">return</span>;</span><br><span class="line">    &#125;</span><br><span class="line">    </span><br><span class="line">    rc = mach_port_insert_right(mach_task_self(), myExceptionPort, myExceptionPort, MACH_MSG_TYPE_MAKE_SEND);</span><br><span class="line">    <span class="keyword">if</span> (rc != KERN_SUCCESS) &#123;</span><br><span class="line">        <span class="built_in">fprintf</span>(<span class="built_in">stderr</span>, <span class="string">&quot;--------&gt;Fail to insert right&quot;</span>);</span><br><span class="line">        <span class="keyword">return</span>;</span><br><span class="line">    &#125;</span><br><span class="line">    </span><br><span class="line">    rc = thread_set_exception_ports(mach_thread_self(), excMask, myExceptionPort, EXCEPTION_DEFAULT, MACHINE_THREAD_STATE);</span><br><span class="line">    <span class="keyword">if</span> (rc != KERN_SUCCESS) &#123;</span><br><span class="line">        <span class="built_in">fprintf</span>(<span class="built_in">stderr</span>, <span class="string">&quot;--------&gt;Fail to  set exception\\\\\\\\n&quot;</span>);</span><br><span class="line">        <span class="keyword">return</span>;</span><br><span class="line">    &#125;</span><br><span class="line">    </span><br><span class="line">    <span class="comment">// at the end of catchMachExceptions, spawn the exception handling thread</span></span><br><span class="line">    <span class="keyword">pthread_t</span> thread;</span><br><span class="line">    pthread_create(&amp;thread, <span class="literal">NULL</span>, exc_handler, <span class="literal">NULL</span>);</span><br><span class="line">&#125; <span class="comment">// end catchMACHExceptions</span></span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">static</span> <span class="keyword">void</span> *<span class="title">exc_handler</span><span class="params">(<span class="keyword">void</span> *ignored)</span> </span>&#123;</span><br><span class="line">    <span class="comment">// Exception handler – runs a message loop. Refactored into a standalone function</span></span><br><span class="line">    <span class="comment">// so as to allow easy insertion into a thread (can be in same program or different)</span></span><br><span class="line">    <span class="keyword">mach_msg_return_t</span> rc;</span><br><span class="line">    <span class="built_in">fprintf</span>(<span class="built_in">stderr</span>, <span class="string">&quot;Exc handler listening\\\\\\\\n&quot;</span>);</span><br><span class="line">    <span class="comment">// The exception message, straight from mach/exc.defs (following MIG processing) // copied here for ease of reference.</span></span><br><span class="line">    <span class="keyword">typedef</span> <span class="class"><span class="keyword">struct</span> &#123;</span></span><br><span class="line">        <span class="keyword">mach_msg_header_t</span> Head;</span><br><span class="line">        <span class="comment">/* start of the kernel processed data */</span></span><br><span class="line">        <span class="keyword">mach_msg_body_t</span> msgh_body;</span><br><span class="line">        <span class="keyword">mach_msg_port_descriptor_t</span> thread;</span><br><span class="line">        <span class="keyword">mach_msg_port_descriptor_t</span> task;</span><br><span class="line">        <span class="comment">/* end of the kernel processed data */</span></span><br><span class="line">        NDR_record_t NDR;</span><br><span class="line">        <span class="keyword">exception_type_t</span> exception;</span><br><span class="line">        <span class="keyword">mach_msg_type_number_t</span> codeCnt;</span><br><span class="line">        <span class="keyword">integer_t</span> code[<span class="number">2</span>];</span><br><span class="line">        <span class="keyword">int</span> flavor;</span><br><span class="line">        <span class="keyword">mach_msg_type_number_t</span> old_stateCnt;</span><br><span class="line">        <span class="keyword">natural_t</span> old_state[<span class="number">144</span>];</span><br><span class="line">    &#125; Request;</span><br><span class="line">    </span><br><span class="line">    Request exc;</span><br><span class="line"></span><br><span class="line">    <span class="class"><span class="keyword">struct</span> <span class="title">rep_msg</span> &#123;</span></span><br><span class="line">        <span class="keyword">mach_msg_header_t</span> Head;</span><br><span class="line">        NDR_record_t NDR;</span><br><span class="line">        <span class="keyword">kern_return_t</span> RetCode;</span><br><span class="line">    &#125; rep_msg;</span><br><span class="line">    </span><br><span class="line">    </span><br><span class="line">    <span class="keyword">for</span>(;;) &#123;</span><br><span class="line">        <span class="comment">// Message Loop: Block indefinitely until we get a message, which has to be</span></span><br><span class="line">        <span class="comment">// 这里会阻塞，直到接收到exception message，或者线程被中断。</span></span><br><span class="line">        <span class="comment">// an exception message (nothing else arrives on an exception port)</span></span><br><span class="line">        rc = mach_msg( &amp;exc.Head,</span><br><span class="line">                      MACH_RCV_MSG|MACH_RCV_LARGE,</span><br><span class="line">                      <span class="number">0</span>,</span><br><span class="line">                      <span class="keyword">sizeof</span>(Request),</span><br><span class="line">                      myExceptionPort, <span class="comment">// Remember this was global – that&#x27;s why.</span></span><br><span class="line">                      MACH_MSG_TIMEOUT_NONE,</span><br><span class="line">                      MACH_PORT_NULL);</span><br><span class="line">        </span><br><span class="line">        <span class="keyword">if</span>(rc != MACH_MSG_SUCCESS) &#123;</span><br><span class="line">            <span class="comment">/*... */</span></span><br><span class="line">            <span class="keyword">break</span> ;</span><br><span class="line">        &#125;;</span><br><span class="line"></span><br><span class="line">         <span class="comment">// Normally we would call exc_server or other. In this example, however, we wish</span></span><br><span class="line">        <span class="comment">// to demonstrate the message contents:</span></span><br><span class="line">        </span><br><span class="line">        <span class="built_in">printf</span>(<span class="string">&quot;Got message %d. Exception : %d Flavor: %d. Code %lld/%lld. State count is %d\\\\\\\\n&quot;</span> ,</span><br><span class="line">               exc.Head.msgh_id, exc.exception, exc.flavor,</span><br><span class="line">               exc.code[<span class="number">0</span>], exc.code[<span class="number">1</span>], <span class="comment">// can also print as 64-bit quantity</span></span><br><span class="line">               exc.old_stateCnt);</span><br><span class="line">        </span><br><span class="line">        rep_msg.Head = exc.Head;</span><br><span class="line">        rep_msg.NDR = exc.NDR;</span><br><span class="line">        rep_msg.RetCode = KERN_FAILURE;</span><br><span class="line">        </span><br><span class="line">        <span class="keyword">kern_return_t</span> result;</span><br><span class="line">        <span class="keyword">if</span> (rc == MACH_MSG_SUCCESS) &#123;</span><br><span class="line">            result = mach_msg(&amp;rep_msg.Head,</span><br><span class="line">                              MACH_SEND_MSG,</span><br><span class="line">                              <span class="keyword">sizeof</span> (rep_msg),</span><br><span class="line">                              <span class="number">0</span>,</span><br><span class="line">                              MACH_PORT_NULL,</span><br><span class="line">                              MACH_MSG_TIMEOUT_NONE,</span><br><span class="line">                              MACH_PORT_NULL);</span><br><span class="line">        &#125;</span><br><span class="line">    &#125;</span><br><span class="line">    </span><br><span class="line">    <span class="keyword">return</span>  <span class="literal">NULL</span>;</span><br><span class="line">    </span><br><span class="line">&#125; <span class="comment">// end exc_handler</span></span><br><span class="line"></span><br></pre></td></tr></table></figure>

<p>接下来，我们测试一下。</p>
<figure class="highlight angelscript"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">- (<span class="built_in">void</span>)test</span><br><span class="line">&#123;</span><br><span class="line"><span class="string">    [self test]</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>
<p>结果如下:</p>
<figure class="highlight angelscript"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">Exc handler listening</span><br><span class="line">Got message <span class="number">2401.</span> Exception : <span class="number">1</span> Flavor: <span class="number">0.</span> Code <span class="number">2</span>/<span class="number">1486065656.</span> State count <span class="keyword">is</span> <span class="number">8</span></span><br><span class="line">(lldb)</span><br></pre></td></tr></table></figure>

<p>我们可以查看<code>mach/exception_types.h</code> 对exception type的定义</p>
<p>Exception:  1,  即为EXC_BAD_ACCESS<br>code:       2,  即KERN_PROTECTION_FAILURE</p>
<p>而ux_exception() 函数告诉我们Code与signal是怎么转换的。<br>也就是 Exception = EXC_BAD_ACCESS， code = 2 对应的是SIGBUS信号，又因为为是stack overflow，信号应该是SIGSEGV。<br>那么结这个exception就是:</p>
<blockquote>
<p>Exception Type: EXC_BAD_ACCESS (SIGSEGV)<br>Exception Subtype: KERN_PROTECTION_FAILURE</p>
</blockquote>
<p>再试试其他的：</p>
<figure class="highlight angelscript"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">int</span> *pi = (<span class="built_in">int</span>*)<span class="number">0x00001111</span>;</span><br><span class="line">*pi = <span class="number">17</span>;</span><br></pre></td></tr></table></figure>
<blockquote>
<p>Exc handler listening<br>Got message 2401. Exception : 1 Flavor: 0. Code 1/4369. State count is 8(lldb) </p>
</blockquote>
<blockquote>
<p>Exception Type: EXC_BAD_ACCESS (SIGSEGV)<br>Exception Subtype: KERN_INVALID_ADDRESS</p>
</blockquote>
<h2 id="最后"><a href="#最后" class="headerlink" title="最后"></a>最后</h2><p>除了上面硬件产生的信号，另外还有软件产生的信号。软件产生的信号来自kill()、pthread_kill()两个函数的调用，大概过程是这样的：kill()/pthread_kill() –&gt; … –&gt; psignal_internal() –&gt; act_set_astbsd()。最终也会调用act_set_astbsd()发送信号到目标线程。这意味着Mach exception流程是不会走的。<br>另外，在abort()源码注释着：<code>&lt;rdar://problem/7397932&gt; abort() should call pthread_kill to deliver a signal to the aborting thread</code> , 它是这样调用的(void)pthread_kill(pthread_self(), SIGABRT);。Apple’s Crash Reporter 把<code>SIGABRT</code>的Mach exception type记为<code>EXC_CRASH</code>，不同与上面转变表。</p>
<blockquote>
<p>Exception Type: EXC_CRASH (SIGABRT)<br>Exception Codes: 0x0000000000000000, 0x0000000000000000</p>
</blockquote>
<p>所以尽管Mach exception handle 比 UNIX signal handle 更有优势，但我们还是须要注册signal handle用于处理EXC_SOFTWARE/EXC_CRASH。</p>
          <!--noindex-->
            <div class="post-button">
              <a class="btn" href="/blogwebpage/iOS/crashreport/crashanalysis.html#more" rel="contents">
                阅读全文 &raquo;
              </a>
            </div>
          <!--/noindex-->
        
      
    </div>

    
    
    
      <footer class="post-footer">
        <div class="post-eof"></div>
      </footer>
  </article>
  
  
  

      
  
  
  <article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-CN">
    <link itemprop="mainEntityOfPage" href="https://wangkejie.gitee.io/blogwebpage/iOS/kernelarchitecture/xnu.html">

    <span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
      <meta itemprop="image" content="/blogwebpage/images/avatar.gif">
      <meta itemprop="name" content="Jack Wang">
      <meta itemprop="description" content="书山有路勤为径，学海无涯苦作舟！">
    </span>

    <span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
      <meta itemprop="name" content="王科杰">
    </span>
      <header class="post-header">
        <h2 class="post-title" itemprop="name headline">
          
            <a href="/blogwebpage/iOS/kernelarchitecture/xnu.html" class="post-title-link" itemprop="url">Mach微内核简介</a>
        </h2>

        <div class="post-meta">
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-calendar"></i>
              </span>
              <span class="post-meta-item-text">发表于</span>

              <time title="创建时间：2019-07-14 12:26:39" itemprop="dateCreated datePublished" datetime="2019-07-14T12:26:39+08:00">2019-07-14</time>
            </span>
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-folder"></i>
              </span>
              <span class="post-meta-item-text">分类于</span>
                <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
                  <a href="/blogwebpage/categories/iOS/" itemprop="url" rel="index"><span itemprop="name">iOS</span></a>
                </span>
                  ，
                <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
                  <a href="/blogwebpage/categories/iOS/XNU-App%E5%A6%82%E4%BD%95%E5%8A%A0%E8%BD%BD/" itemprop="url" rel="index"><span itemprop="name">XNU:App如何加载</span></a>
                </span>
            </span>

          

        </div>
      </header>

    
    
    
    <div class="post-body" itemprop="articleBody">

      
          <h1 id="XNU-怎么加载-App"><a href="#XNU-怎么加载-App" class="headerlink" title="XNU 怎么加载 App?"></a>XNU 怎么加载 App?</h1><p>iOS 的可执行文件和动态库都是 Mach-O 格式，所以加载 APP 实际上就是加载 Mach-O 文件。<br>Mach-O header 信息结构代码如下:</p>
<figure class="highlight objc"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">struct</span> mach_header_64 &#123;</span><br><span class="line">    uint32_t        magic;          <span class="comment">//64位还是32位</span></span><br><span class="line">    cpu_type_t      cputype;        <span class="comment">//CPU 类型，比如 arm 或 X86</span></span><br><span class="line">    cpu_subtype_t   cpusubtype;     <span class="comment">//CPU 子类型，比如 armv8</span></span><br><span class="line">    uint32_t        filetype;       <span class="comment">// 文件类型</span></span><br><span class="line">    uint32_t        ncmds;          <span class="comment">// load commands 的数量</span></span><br><span class="line">    uint32_t        sizeofcmds;     <span class="comment">// load commands 大小</span></span><br><span class="line">    uint32_t        flags;          <span class="comment">// 标签</span></span><br><span class="line">    uint32_t        reserved;       <span class="comment">// 保留字段</span></span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>

<p>其中，文件类型 filetype 表示了当前 Mach-O 属于哪种类型。Mach-O 包括以下几种类型。</p>
<ul>
<li>OBJECT，指的是 .o 文件或者 .a 文件;</li>
<li>EXECUTE，指的是IPA 拆包后的文件;</li>
<li>DYLIB，指的是 .dylib 或 .framework 文件; </li>
<li>DYLINKER，指的是动态链接器; </li>
<li>DSYM，指的是保存有符号信息用于分析闪退信息的文件。</li>
</ul>
<p>加载 Mach-O 文件，内核会 fork 进程，并对进程进行一些基本设置，比如为进程分配虚拟内存、为进程创 建主线程、代码签名等。用户态 dyld 会对 Mach-O 文件做库加载和符号解析。</p>

      
    </div>

    
    
    
      <footer class="post-footer">
        <div class="post-eof"></div>
      </footer>
  </article>
  
  
  

      
  
  
  <article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-CN">
    <link itemprop="mainEntityOfPage" href="https://wangkejie.gitee.io/blogwebpage/iOS/kernelarchitecture/mach.html">

    <span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
      <meta itemprop="image" content="/blogwebpage/images/avatar.gif">
      <meta itemprop="name" content="Jack Wang">
      <meta itemprop="description" content="书山有路勤为径，学海无涯苦作舟！">
    </span>

    <span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
      <meta itemprop="name" content="王科杰">
    </span>
      <header class="post-header">
        <h2 class="post-title" itemprop="name headline">
          
            <a href="/blogwebpage/iOS/kernelarchitecture/mach.html" class="post-title-link" itemprop="url">Mach微内核简介</a>
        </h2>

        <div class="post-meta">
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-calendar"></i>
              </span>
              <span class="post-meta-item-text">发表于</span>

              <time title="创建时间：2019-07-14 12:26:39" itemprop="dateCreated datePublished" datetime="2019-07-14T12:26:39+08:00">2019-07-14</time>
            </span>
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-folder"></i>
              </span>
              <span class="post-meta-item-text">分类于</span>
                <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
                  <a href="/blogwebpage/categories/iOS/" itemprop="url" rel="index"><span itemprop="name">iOS</span></a>
                </span>
                  ，
                <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
                  <a href="/blogwebpage/categories/iOS/Mach%E5%86%85%E6%A0%B8/" itemprop="url" rel="index"><span itemprop="name">Mach内核</span></a>
                </span>
            </span>

          

        </div>
      </header>

    
    
    
    <div class="post-body" itemprop="articleBody">

      
          <h1 id="Mach"><a href="#Mach" class="headerlink" title="Mach"></a>Mach</h1><p>OS X内核的基本服务和基本类型都基于Mach 3.0。苹果对Mach进行了修改和扩展，以更好地满足OS X的功能和性能目标。</p>
<p>Mach 3.0最初被认为是一个简单、可扩展的通信微内核。它能够作为一个独立的内核运行，而其他传统的操作系统服务(如I/O、文件系统和网络堆栈)作为用户模式服务器运行。</p>
<p>然而，在OS X中，Mach与其他内核组件<code>链接到一个内核地址空间</code>中。这主要是<code>为了性能</code>;在链接组件之间进行直接调用要比在单独<code>任务之间发送消息</code>或<code>执行远程过程调用(RPC)</code>快得多。这种模块化的结构导致了一个比单一内核所允许的更健壮和可扩展的系统，而没有纯微内核的性能损失。</p>
<p>因此，在OS X中，Mach主要不是客户机和服务器之间的通信中心。相反，它的价值由抽象、可扩展性和灵活性组成。特别地，Mach提供了</p>
<ul>
<li>基于对象的api，使用通信通道(例如端口)作为对象引用</li>
<li>高度并行执行，包括预先调度的线程和对SMP的支持</li>
<li>一个灵活的调度框架，支持实时使用</li>
<li>一组完整的IPC原语，包括消息传递、RPC、同步和通知</li>
<li>支持大型虚拟地址空间、共享内存区域和由持久性存储支持的内存对象</li>
<li>经过验证的可扩展性和可移植性，例如跨指令集体系结构和分布式环境</li>
<li>安全与资源管理作为设计的基本原则;所有资源都是虚拟化的</li>
</ul>
<h1 id="Mach内核抽象化"><a href="#Mach内核抽象化" class="headerlink" title="Mach内核抽象化"></a>Mach内核抽象化</h1><p>Mach提供了一组被设计成既简单又强大的抽象。这些是主要的内核抽象:</p>
<ul>
<li>任务(Tasks)。资源所有权单位;每个任务由一个虚拟地址空间、一个端口名称空间和一个或多个线程组成。(类似于流程。)</li>
<li>线程(Threads)。任务中CPU执行的单位。</li>
<li>地址空间(Address space)。与内存管理器一起，Mach实现了稀疏虚拟地址空间和共享内存的概念。</li>
<li>内存对象(Memory objects)。内存管理的内部单元。内存对象包括命名项和区域;它们表示可能映射到地址空间的持久数据。</li>
<li>端口(Ports)。安全、简单的通信通道，只能通过发送和接收功能(称为端口权限)访问。</li>
<li>IPC。消息队列、远程过程调用、通知、信号量和锁集。</li>
<li>时间(Time)。时钟、定时器和等待。</li>
</ul>
<p>在陷阱级别，大多数Mach抽象的接口由<code>表示这些对象的内核端口之间</code>的<code>消息</code>组成。陷阱(trap)级别的<code>接口</code>(例如mach_msg_overwrite_trap)和<code>消息格式</code>在正常使用中由Mach接口生成器(MIG)抽象出来。MIG用于编译基于消息的api的<code>过程接口</code>，基于这些api的<code>描述</code>。（MIG参看下面总结部分）</p>
<h1 id="任务和线程"><a href="#任务和线程" class="headerlink" title="任务和线程"></a>任务和线程</h1><p>OS X进程和POSIX线程(pthreads)分别在Mach任务和线程之上实现。线程是任务中的控制流点。存在一个任务来为其包含的线程提供资源。这种分割是为了提供并行性和资源共享。</p>
<p>一个线程</p>
<ul>
<li>是任务中的控制流点。</li>
<li>可以访问包含任务的所有元素。</li>
<li>与其他线程(可能)并行执行，甚至是同一任务中的线程。</li>
<li>具有最小的状态信息，以降低开销。</li>
</ul>
<p>一个任务</p>
<ul>
<li>是系统资源的集合。这些资源(地址空间除外)由端口引用。如果对端口被分配了权限，那么这些资源可以与其他任务共享。</li>
<li>提供一个大的、可能稀疏的地址空间，由虚拟地址引用。这个空间的一部分可以通过继承或外部内存管理共享。</li>
<li>包含一些线程。</li>
</ul>
<p>请注意，任务没有自己的线程执行指令的生命周期。当说“task Y做X”时，真正的意思是“task Y中包含的线程做X”。</p>
<ol>
<li><p>任务是一个相当昂贵的实体。它的存在是资源的集合。任务中的所有线程都共享所有内容。如果没有显式的操作(尽管操作通常很简单)，两个任务就不能共享任何内容，而且一些资源(例如端口接收权限)根本不能在两个任务之间共享。</p>
</li>
<li><p>线程是一个相当轻量级的实体。它的创建成本相当低，操作开销也很低。这是真的，因为一个线程只有很少的状态信息(主要是它的寄存器状态)。它所拥有的任务承担着资源管理的重担。在多处理器计算机上，任务中的多个线程可以并行执行。即使并行性不是目标，多线程也有一个优势，即每个线程都可以使用同步编程风格，而不是试图使用单个线程进行异步编程来提供多个服务。</p>
</li>
<li><p>线程是基本的计算实体。一个线程只属于一个任务，这个任务定义了它的虚拟地址空间。影响地址空间的结构或引用任何资源以外的地址空间,线程必须执行一个<code>特殊的陷阱指令</code> 引起<code>内核代表线程</code>执行操作或<code>发送消息代理</code>代表线程。通常，这些陷阱操作与包含线程的任务相关的资源。内核可以发出请求来操作这些实体:创建它们、删除它们并影响它们的状态。</p>
</li>
<li><p>Mach为线程调度策略提供了一个灵活的框架。OS X的早期版本同时支持分时和固定优先级策略。提高和降低分时线程的优先级，以平衡它与其他分时线程之间的资源消耗。</p>
</li>
<li><p>固定优先级的线程执行一定的时间量，然后放在具有相同优先级的线程队列的末尾。将固定优先级线程的量子级别设置为无穷大，可以让线程一直运行，直到阻塞，或者直到被优先级更高的线程抢占为止。<code>高优先级实时线程</code>通常是<code>固定优先级</code>的。</p>
</li>
<li><p>OS X还为实时性能提供了时间约束调度。这个调度允许您指定线程必须在一定时间内获得一定的时间量。</p>
</li>
</ol>
<p>Mach调度在<span class="exturl" data-url="aHR0cHM6Ly9kZXZlbG9wZXIuYXBwbGUuY29tL2xpYnJhcnkvYXJjaGl2ZS9kb2N1bWVudGF0aW9uL0Rhcndpbi9Db25jZXB0dWFsL0tlcm5lbFByb2dyYW1taW5nL3NjaGVkdWxlci9zY2hlZHVsZXIuaHRtbCMvL2FwcGxlX3JlZi9kb2MvdWlkL1RQMzAwMDA5MDUtQ0gyMTEtQkVISkRGQ0E=">Mach调度和线程接口<i class="fa fa-external-link-alt"></i></span>中有进一步的描述。</p>
<h1 id="端口、端口权限、端口集和端口名称空间"><a href="#端口、端口权限、端口集和端口名称空间" class="headerlink" title="端口、端口权限、端口集和端口名称空间"></a>端口、端口权限、端口集和端口名称空间</h1><p>除了任务的虚拟地址空间之外，所有其他Mach资源都是通过称为端口的间接级别访问的。端口是请求服务的客户机和提供服务的服务器之间单向通信通道的端点。如果要向此类服务请求提供应答，则必须使用第二个端口。这类似于UNIX中的(单向)管道。</p>
<p>在大多数情况下，<code>由端口访问的资源(即由端口命名的资源)被称为对象</code>。大多数由端口命名的对象都有<code>一个接收方</code>和(可能的)<code>多个发送方</code>。也就是说，对于典型对象(如消息队列)，只有一个接收端口，至少有一个发送端口。</p>
<p>对象提供的服务由接收发送到对象的请求的管理器决定。因此，内核是与内核提供的对象关联的端口的接收方，而与任务提供的对象关联的端口的接收方是提供这些对象的任务。</p>
<p>对于命名任务提供的对象的端口，可以将该端口的请求接收方更改为不同的任务，例如通过在消息中将该端口传递给该任务。一个任务可能有多个引用其支持的资源的端口。就此而言，任何给定的实体都可以有多个表示它的端口，每个端口表示不同的允许操作集。例如，许多对象都有一个名称端口和一个控制端口(有时称为特权端口)。对控制端口的访问允许操作对象;对name端口的访问简单地为对象命名，这样您就可以获得关于它的信息，或者对它执行其他非特权操作。</p>
<p>任务具有以特定方式访问端口的权限(发送、接收、发送一次);这些被称为port rights。端口只能通过右值访问。端口通常用于授予客户机对Mach内对象的访问权。有权发送到对象的IPC端口表示有权以规定的方式操作对象。因此，<code>端口所有权是Mach内部的基本安全机制</code>。<code>拥有访问对象的权利</code>就是<code>拥有访问或操作该对象的能力</code>。</p>
<p>端口权限可以通过IPC在<code>任务之间复制和移动</code>。这样做实际上是将功能传递给某个对象或服务器。</p>
<p>一种类型的对象引用一个端口是一个端口组。顾名思义,端口设置一组端口的权利时,可以当作一个单独的单元接收消息或事件的任何成员集。港口集允许一个线程等待的消息和事件源,例如在工作循环。</p>
<p>传统上，在Mach中，由端口表示的通信通道总是消息队列。然而，OS X支持其他类型的通信通道，这些新的IPC对象类型也由端口和端口权限表示。有关消息和其他IPC类型的详细信息，请参阅下面进程间通信(Interprocess Communication, IPC)一节。</p>
<p>端口和端口权限没有允许直接操作任意端口或权限的系统范围名称。只有当任务在其端口名称空间中具有端口权时，才可以由任务操作端口。端口权由端口名称指定，一个整数索引进入一个32位端口名称空间。每个任务都与它关联一个端口名称空间。</p>
<p>当另一个任务显式地将它们插入它的名称空间时，当它们在消息中接收到权限时，任务通过创建返回对象权限的对象获得端口权限，并通过Mach调用特定的特殊端口(mach_thread_self、mach_task_self和mach_reply_port)获得端口权限。</p>
<h1 id="内存管理"><a href="#内存管理" class="headerlink" title="内存管理"></a>内存管理</h1><p>与大多数现代操作系统一样，Mach提供对大型、稀疏的虚拟地址空间的寻址。运行时访问是通过虚拟地址进行的，这些虚拟地址可能与初始访问时物理内存中的位置不对应。Mach负责获取一个请求的虚拟地址，并在物理内存中为它分配一个相应的位置。它通过请求分页来实现这一点。</p>
<p>当内存对象映射到虚拟地址空间的范围时，将用数据填充虚拟地址空间的范围。地址空间中的所有数据最终都是通过内存对象提供的。Mach在物理内存中建立页面时，向内存对象(分页器)的所有者询问页面的内容，并在回收页面之前将可能修改过的数据返回给分页器。OS X包含两个内置分页器——默认分页器和vnode分页器(default pager and the vnode pager)。</p>
<p>默认的分页器处理非持久性内存，称为匿名内存。匿名内存是零初始化的，并且只在任务执行期间存在。vnode分页器将文件映射到内存对象。Mach向内存对象导出一个接口，允许用户模式任务提供内存对象的内容。这个接口称为外部内存管理接口(EMMI)。</p>
<p>内存管理子系统导出称为命名项或命名内存项的虚拟内存句柄。与大多数内核资源一样，这些资源由端口表示。拥有一个命名的内存条目句柄，允许所有者映射底层虚拟内存对象，或者将映射底层对象的权利传递给其他人。在两个不同的任务中映射命名项会在两个任务之间生成共享内存窗口，从而为建立共享内存提供了一种灵活的方法。</p>
<p>从OS X v10.1开始，EMMI系统得到了增强，以支持“无端口”EMMI。在传统的EMMI中，为每个内存区域创建两个Mach端口，同样也为每个缓存的vnode创建两个端口。在最初的实现中，无端口的EMMI用直接内存引用(基本上是指针)替换了这一点。在将来的版本中，端口将用于与内核外部的分页器通信，同时使用直接引用与驻留在内核空间中的分页器通信。这些更改的最终结果是，早期版本的无端口EMMI不支持运行在内核空间之外的分页器。这种支持有望在未来的版本中恢复。</p>
<p>虚拟内存空间的地址范围也可以通过直接分配(使用vm_allocation)来填充。底层虚拟内存对象是匿名的，并由默认分页程序支持。地址空间的共享范围也可以通过继承设置。创建新任务时，将从父任务中克隆它们。这种克隆也属于底层内存地址空间。根据与映射相关的属性，对象的映射部分可以作为副本继承，也可以作为共享，或者根本不可以。Mach采用一种称为“写中复制”的延迟复制形式，以优化任务创建时继承副本的性能。</p>
<p>不是直接复制范围，而是通过受保护的共享来实现写时复制优化。这两个任务共享要复制的内存，但具有只读访问。当任何一个任务试图修改范围的一部分时，该部分将被复制。这种对内存副本的延迟计算是一种重要的优化，它允许在几个方面进行简化，尤其是消息传递api。</p>
<p>Mach还提供了另一种形式的共享，通过导出指定的区域。命名区域是命名条目的一种形式，但是它不是由虚拟内存对象支持的，而是由虚拟映射片段支持的。这个片段可能包含到许多虚拟内存对象的映射。它可以映射到其他虚拟映射，提供了一种方法，不仅可以继承一组虚拟内存对象，还可以继承它们现有的映射关系。该特性在任务设置中提供了重要的优化，例如在共享用于共享库的地址空间的复杂区域时。</p>
<h1 id="进程间通信-IPC"><a href="#进程间通信-IPC" class="headerlink" title="进程间通信(IPC)"></a>进程间通信(IPC)</h1><p>任务之间的通信是Mach哲学的一个重要元素。Mach支持客户机/服务器系统结构，其中任务(客户机)通过通过通信通道发送的消息请求其他任务(服务器)来访问服务。</p>
<p>Mach中这些通信通道的端点称为端口，而端口权限表示使用该通道的权限。Mach提供的IPC形式包括</p>
<ul>
<li>消息队列</li>
<li>信号量</li>
<li>通知</li>
<li>锁集</li>
<li>远程过程调用(rpc)</li>
</ul>
<p>由端口表示的IPC对象的类型决定了该端口上允许的操作，以及数据传输的方式(和是否)。</p>
<blockquote>
<p>重要提示:OS X中的IPC设施处于过渡状态。在系统的早期版本中，并不是所有这些IPC类型都可以实现。</p>
</blockquote>
<p>对于端口的原始操作，有两种基本不同的Mach api, mach_ipc家族和mach_msg家族。在合理的范围内，这两个系列都可以用于任何IPC对象;然而，在新代码中，mach_ipc调用是首选的。mach_ipc调用在适当的地方维护状态信息，以便支持事务的概念。mach_msg调用支持遗留代码，但不推荐使用;他们是无状态的。</p>
<h2 id="IPC事务和事件调度"><a href="#IPC事务和事件调度" class="headerlink" title="IPC事务和事件调度"></a>IPC事务和事件调度</h2><p>当线程调用mach_ipc_dispatch,它反复处理事件设置的注册端口。这些事件可以从RPC参数块对象(如客户调用的结果),一个锁对象被(由于其他线程释放锁),通知或信号量被发布或消息来自一个传统的消息队列。</p>
<p>这些事件通过mach_msg_dispatch的调用来处理。有些事件暗示调用生命周期内存在事务。在锁的情况下，状态是锁的所有权。当callout返回时，锁被释放。在远程过程调用的情况下，状态是客户机的标识、参数块和应答端口。当callout返回时，将发送应答。</p>
<p>当callout返回时，事务(如果有的话)就完成了，线程等待下一个事件。mach_ipc_dispatch工具旨在支持工作循环。</p>
<h2 id="消息队列"><a href="#消息队列" class="headerlink" title="消息队列"></a>消息队列</h2><p>最初，Mach中进程间通信的唯一样式是消息队列。只有一个任务可以持有表示消息队列的端口的接收权。这个任务允许从端口队列接收(读取)消息。多个任务可以拥有向队列发送(写)消息的端口的权限。</p>
<p>任务通过构建包含一组数据元素的数据结构与另一个任务通信，然后在其拥有发送权限的端口上执行消息发送操作。稍后，具有该端口接收权限的任务将执行消息接收操作。</p>
<p>一条消息可包括以下部分或全部:</p>
<ul>
<li>纯数据</li>
<li>存储范围的副本</li>
<li>端口的权利</li>
<li>内核隐式属性，如发送方的安全令牌</li>
</ul>
<p>消息传输是一个异步操作。消息逻辑上被复制到接收任务中，可能使用写时复制优化。接收任务中的多个线程可以尝试从给定端口接收消息，但是只有一个线程可以接收任何给定的消息。</p>
<h2 id="信号量"><a href="#信号量" class="headerlink" title="信号量"></a>信号量</h2><p>信号量IPC对象支持等待、post和post所有操作。这些是计数信号量，如果在该信号量的等待队列中当前没有线程在等待，则保存(计数)post。post all操作将唤醒所有当前等待的线程。</p>
<h2 id="通知"><a href="#通知" class="headerlink" title="通知"></a>通知</h2><p>与信号量一样，通知对象也支持post和wait操作，但添加了一个state字段。状态是一个固定大小、固定格式的字段，在创建通知对象时定义。每个post更新状态字段;每个post都覆盖一个状态。</p>
<h2 id="锁"><a href="#锁" class="headerlink" title="锁"></a>锁</h2><p>锁是提供对临界区互斥访问的对象。锁的主要接口是面向事务的(参见IPC事务和事件调度)。在事务期间，线程持有锁。当它从事务返回时，锁被释放。</p>
<h2 id="远程过程调用-RPC-对象"><a href="#远程过程调用-RPC-对象" class="headerlink" title="远程过程调用(RPC)对象"></a>远程过程调用(RPC)对象</h2><p>顾名思义，RPC对象旨在促进和优化远程过程调用。RPC对象的主要接口是面向事务的(参见IPC事务和事件调度)</p>
<p>当创建RPC对象时，定义一组参数块格式。当客户机发出RPC(对象上的发送)时，它会导致以预定义格式之一的消息创建并在对象上排队，然后最终传递给服务器(接收方)。当服务器从事务返回时，将回复返回给发送方。Mach试图通过使用客户机的资源执行服务器来优化事务;这称为<code>线程迁移</code>。</p>
<h1 id="时间管理"><a href="#时间管理" class="headerlink" title="时间管理"></a>时间管理</h1><p>Mach中时间的传统抽象是时钟，它提供了一组基于mach_timspec_t的异步报警服务。有一个或多个时钟对象，每个对象定义一个以纳秒为单位的单调递增的时间值。实时时钟是内置的，是最重要的，但是系统中可能还有其他时钟用于其他时间概念。时钟支持获取当前时间、给定时间段的睡眠、设置闹钟(在给定时间发送的通知)等操作。</p>
<p>mach_timespec_t API在OS x中是不推荐的。更新的、首选的API基于计时器对象，而计时器对象又使用AbsoluteTime作为基本数据类型。AbsoluteTime是一种依赖于机器的类型，通常基于平台本机时基。提供了一些例程来将绝对时间值转换为其他数据类型，或者从其他数据类型转换为绝对时间值，比如纳秒。计时器对象支持异步、无漂移通知、取消和提前警报。它们比时钟效率更高，分辨率更高。</p>
<h1 id="我们总结一下"><a href="#我们总结一下" class="headerlink" title="我们总结一下"></a>我们总结一下</h1><h2 id="Mach-、端口、Mach消息部分"><a href="#Mach-、端口、Mach消息部分" class="headerlink" title="Mach 、端口、Mach消息部分"></a>Mach 、端口、Mach消息部分</h2><ul>
<li>在Mach中所有东西（Task、线程、虚拟内存等）都是对象</li>
<li>对象与对象之间通信只能(任务虚拟地址空间)通过<code>端口</code>收发(<code>一个接收方，可以多个发送方</code>)消息。</li>
</ul>
<p>Mach做以下几件事儿：</p>
<ul>
<li>“控制点”或执行单元的管理。</li>
<li>线程或线程组（Task）的资源分配。</li>
<li>虚拟内存的分配和管理。</li>
<li>底层物理资源–即CPU、内存和任何物理设备的分配。</li>
</ul>
<h3 id="Mach消息结构体"><a href="#Mach消息结构体" class="headerlink" title="Mach消息结构体"></a>Mach消息结构体</h3><ul>
<li>最基本的包含两部分：消息头、消息体。可选的消息尾<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">typedef</span>	<span class="class"><span class="keyword">struct</span> </span></span><br><span class="line"><span class="class">&#123;</span></span><br><span class="line">  <span class="keyword">mach_msg_bits_t</span>	msgh_bits;<span class="comment">//标志位</span></span><br><span class="line">  <span class="keyword">mach_msg_size_t</span>	msgh_size;<span class="comment">//大小</span></span><br><span class="line">  <span class="keyword">mach_port_t</span>		msgh_remote_port;<span class="comment">//目标端口（发送：接受方，接收：发送方）</span></span><br><span class="line">  <span class="keyword">mach_port_t</span>		msgh_local_port; <span class="comment">//源端口（发送：发送方，接收：接收方）</span></span><br><span class="line">  <span class="keyword">mach_port_name_t</span>	msgh_voucher_port;</span><br><span class="line">  <span class="keyword">mach_msg_id_t</span>		msgh_id;</span><br><span class="line">&#125; <span class="keyword">mach_msg_header_t</span>; <span class="comment">//消息头</span></span><br><span class="line"><span class="keyword">typedef</span> <span class="class"><span class="keyword">struct</span></span></span><br><span class="line"><span class="class">&#123;</span></span><br><span class="line">        <span class="keyword">mach_msg_size_t</span> msgh_descriptor_count;</span><br><span class="line">&#125; <span class="keyword">mach_msg_body_t</span>;<span class="comment">//消息体</span></span><br><span class="line"><span class="keyword">typedef</span> <span class="class"><span class="keyword">struct</span></span></span><br><span class="line"><span class="class">&#123;</span></span><br><span class="line">        <span class="keyword">mach_msg_header_t</span>       header;</span><br><span class="line">        <span class="keyword">mach_msg_body_t</span>         body;</span><br><span class="line">&#125; <span class="keyword">mach_msg_base_t</span>; <span class="comment">//基本消息</span></span><br><span class="line"><span class="keyword">typedef</span>	<span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="keyword">mach_msg_trailer_type_t</span>;<span class="comment">//消息尾的类型</span></span><br><span class="line"><span class="keyword">typedef</span> <span class="class"><span class="keyword">struct</span> </span></span><br><span class="line"><span class="class">&#123;</span></span><br><span class="line">  <span class="keyword">mach_msg_trailer_type_t</span>	msgh_trailer_type;</span><br><span class="line">  <span class="keyword">mach_msg_trailer_size_t</span>	msgh_trailer_size;</span><br><span class="line">&#125; <span class="keyword">mach_msg_trailer_t</span>; <span class="comment">//消息尾</span></span><br></pre></td></tr></table></figure></li>
<li>复杂一点的，将消息头的标志位mach_msg_bits_t设置为MACH_MSGH_BITS_COMPLEX，就表示复杂消息。此时消息体里面指定了描述符的个数，接下来就是一个接着一个的描述符：<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">typedef</span> <span class="class"><span class="keyword">struct</span></span></span><br><span class="line"><span class="class">&#123;</span></span><br><span class="line">  <span class="keyword">uint64_t</span>			address;<span class="comment">//数据的大小</span></span><br><span class="line">  <span class="keyword">boolean_t</span>     		deallocate: <span class="number">8</span>;<span class="comment">//发送之后是否接触分配</span></span><br><span class="line">  <span class="keyword">mach_msg_copy_options_t</span>       copy: <span class="number">8</span>;<span class="comment">//复制指令</span></span><br><span class="line">  <span class="keyword">unsigned</span> <span class="keyword">int</span>     		pad1: <span class="number">8</span>;</span><br><span class="line">  <span class="keyword">mach_msg_descriptor_type_t</span>    type: <span class="number">8</span>;</span><br><span class="line">  <span class="keyword">mach_msg_size_t</span>       	size;<span class="comment">//数据的大小</span></span><br><span class="line">&#125; <span class="keyword">mach_msg_ool_descriptor64_t</span>;</span><br><span class="line"></span><br></pre></td></tr></table></figure></li>
</ul>
<h3 id="消息收发"><a href="#消息收发" class="headerlink" title="消息收发"></a>消息收发</h3><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">extern</span> <span class="keyword">mach_msg_return_t</span>	<span class="title">mach_msg</span><span class="params">(</span></span></span><br><span class="line"><span class="function"><span class="params">					<span class="keyword">mach_msg_header_t</span> *msg,</span></span></span><br><span class="line"><span class="function"><span class="params">					<span class="keyword">mach_msg_option_t</span> option,</span></span></span><br><span class="line"><span class="function"><span class="params">					<span class="keyword">mach_msg_size_t</span> send_size,</span></span></span><br><span class="line"><span class="function"><span class="params">					<span class="keyword">mach_msg_size_t</span> rcv_size,</span></span></span><br><span class="line"><span class="function"><span class="params">					<span class="keyword">mach_port_name_t</span> rcv_name,</span></span></span><br><span class="line"><span class="function"><span class="params">					<span class="keyword">mach_msg_timeout_t</span> timeout,</span></span></span><br><span class="line"><span class="function"><span class="params">					<span class="keyword">mach_port_name_t</span> notify)</span></span>;</span><br></pre></td></tr></table></figure>

<p>步骤如下：<br>发送消息：</p>
<ul>
<li>调用current_space()获取当前的IPC空间。</li>
<li>调用current_map()获取虚拟空间</li>
<li>消息大小正确性检查</li>
<li>计算要分配的消息大小</li>
<li>通过ipc_kmsg_alloc分配消息</li>
<li>复制消息</li>
<li>复制消息关联的端口权限，然后通过ipc_kmsg_copyin将所有的out-of-line数据的内存复制到当前虚拟空间。(如果不复制权限可能导致无法访问数据)</li>
<li>调用ipc_kmsg_send()发送消息<ul>
<li>获得msgh_remote_port引用并锁定端口</li>
<li>调用ipc_mqueue_send()，将消息直接复制到端口的ipc_messages队列中并唤醒等待的线程。</li>
</ul>
</li>
</ul>
<p>接收消息</p>
<ul>
<li>调用current_space()获取当前的IPC空间。</li>
<li>调用current_map()获取虚拟空间</li>
<li>调用ipc_mqueue_copyin()获取IPC队列。</li>
<li>调用ipc_mqueue_receive()从队列中取出消息</li>
<li>执行</li>
</ul>
<h3 id="端口"><a href="#端口" class="headerlink" title="端口"></a>端口</h3><p>端口实际上就是一个整型的标识符，是如下结构（在osfmk/ipc/ipc_port.h中定义）的一个句柄：</p>
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br></pre></td><td class="code"><pre><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">ipc_port</span> &#123;</span></span><br><span class="line">	<span class="comment">/*</span></span><br><span class="line"><span class="comment">	 * Initial sub-structure in common with ipc_pset</span></span><br><span class="line"><span class="comment">	 * First element is an ipc_object second is a</span></span><br><span class="line"><span class="comment">	 * message queue</span></span><br><span class="line"><span class="comment">	 */</span></span><br><span class="line">	<span class="class"><span class="keyword">struct</span> <span class="title">ipc_object</span> <span class="title">ip_object</span>;</span></span><br><span class="line">	<span class="class"><span class="keyword">struct</span> <span class="title">ipc_mqueue</span> <span class="title">ip_messages</span>;</span></span><br><span class="line">	<span class="keyword">natural_t</span> ip_sprequests:<span class="number">1</span>,	<span class="comment">/* send-possible requests outstanding */</span></span><br><span class="line">		  ip_spimportant:<span class="number">1</span>,	<span class="comment">/* ... at least one is importance donating */</span></span><br><span class="line">		  ip_impdonation:<span class="number">1</span>,	<span class="comment">/* port supports importance donation */</span></span><br><span class="line">		  ip_tempowner:<span class="number">1</span>,	<span class="comment">/* dont give donations to current receiver */</span></span><br><span class="line">		  ip_guarded:<span class="number">1</span>,         <span class="comment">/* port guarded (use context value as guard) */</span></span><br><span class="line">		  ip_strict_guard:<span class="number">1</span>,	<span class="comment">/* Strict guarding; Prevents user manipulation of context values directly */</span></span><br><span class="line">		  ip_reserved:<span class="number">2</span>,</span><br><span class="line">		  ip_impcount:<span class="number">24</span>;	<span class="comment">/* number of importance donations in nested queue */</span></span><br><span class="line">	<span class="class"><span class="keyword">union</span> &#123;</span></span><br><span class="line">		<span class="class"><span class="keyword">struct</span> <span class="title">ipc_space</span> *<span class="title">receiver</span>;</span></span><br><span class="line">		<span class="class"><span class="keyword">struct</span> <span class="title">ipc_port</span> *<span class="title">destination</span>;</span></span><br><span class="line">		<span class="keyword">ipc_port_timestamp_t</span> timestamp;</span><br><span class="line">	&#125; data;</span><br><span class="line">	<span class="class"><span class="keyword">union</span> &#123;</span></span><br><span class="line">		<span class="keyword">ipc_kobject_t</span> kobject;</span><br><span class="line">		<span class="keyword">ipc_importance_task_t</span> imp_task;</span><br><span class="line">		<span class="keyword">uintptr_t</span> alias;</span><br><span class="line">	&#125; kdata;</span><br><span class="line">		</span><br><span class="line">	<span class="class"><span class="keyword">struct</span> <span class="title">ipc_port</span> *<span class="title">ip_nsrequest</span>;</span></span><br><span class="line">	<span class="class"><span class="keyword">struct</span> <span class="title">ipc_port</span> *<span class="title">ip_pdrequest</span>;</span></span><br><span class="line">	<span class="class"><span class="keyword">struct</span> <span class="title">ipc_port_request</span> *<span class="title">ip_requests</span>;</span></span><br><span class="line">	<span class="class"><span class="keyword">struct</span> <span class="title">ipc_kmsg</span> *<span class="title">ip_premsg</span>;</span></span><br><span class="line">	<span class="keyword">mach_vm_address_t</span> ip_context;</span><br><span class="line">	<span class="keyword">mach_port_mscount_t</span> ip_mscount;</span><br><span class="line">	<span class="keyword">mach_port_rights_t</span> ip_srights;</span><br><span class="line">	<span class="keyword">mach_port_rights_t</span> ip_sorights;</span><br><span class="line"><span class="meta">#<span class="meta-keyword">if</span>	MACH_ASSERT</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span>	IP_NSPARES		4</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span>	IP_CALLSTACK_MAX	16</span></span><br><span class="line"><span class="comment">/*	queue_chain_t	ip_port_links;*/</span><span class="comment">/* all allocated ports */</span></span><br><span class="line">	<span class="keyword">thread_t</span>	ip_thread;	<span class="comment">/* who made me?  thread context */</span></span><br><span class="line">	<span class="keyword">unsigned</span> <span class="keyword">long</span>	ip_timetrack;	<span class="comment">/* give an idea of &quot;when&quot; created */</span></span><br><span class="line">	<span class="keyword">uintptr_t</span>	ip_callstack[IP_CALLSTACK_MAX]; <span class="comment">/* stack trace */</span></span><br><span class="line">	<span class="keyword">unsigned</span> <span class="keyword">long</span>	ip_spares[IP_NSPARES]; <span class="comment">/* for debugging */</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">endif</span>	<span class="comment">/* MACH_ASSERT */</span></span></span><br><span class="line">&#125; __attribute__((__packed__));</span><br></pre></td></tr></table></figure>

<h3 id="Mach接口生成器-MIG"><a href="#Mach接口生成器-MIG" class="headerlink" title="Mach接口生成器 MIG"></a>Mach接口生成器 MIG</h3><p>Mach消息传递模型是远程调用（Remote Procedure Call，RPC）的一种现实(类似Thrift)。在/usr/include/mach目录下可以看到一些.defs文件，这些文件包含了Mach子系统（一组操作）的定义。操作类型如下：</p>
<img src="/blogwebpage/images/iOS/mig_opt.png" class="">

<h2 id="IPC"><a href="#IPC" class="headerlink" title="IPC"></a>IPC</h2><ul>
<li>Mach的每个Task都包含一个指针，这个指针指向一个IPC命名空间，这个IPC命名空间了包含了Task的端口，当然Task还可以获取系统范围的端口，例如：主机端口、特权端口（可以重启机器等）等。</li>
<li>在用户态下，消息传递都是通过mach_msg()函数实现的，这个函数会触发一个mach陷阱mach_msg_trap()，接下来mach_msg_trap()又会调用mach_msg_overwrite_trap()，它会通过MACH_SEND_MSG和MACH_RCV_MSG来判断是发送操作，还是接收操作。</li>
<li>期中内核态中还可以通过mach_msg_receive()和mach_msg_send()来收发数据。</li>
</ul>
<h2 id="主机、时钟、处理器、处理器集"><a href="#主机、时钟、处理器、处理器集" class="headerlink" title="主机、时钟、处理器、处理器集"></a>主机、时钟、处理器、处理器集</h2><h3 id="主机对象-Host"><a href="#主机对象-Host" class="headerlink" title="主机对象 Host"></a>主机对象 Host</h3><p>主机就是一组“特殊”端口的集合，以及一组异常处理程序的集合，同时定义了一个锁用于保护异常处理的并发访问。结构如下：</p>
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="class"><span class="keyword">struct</span>	<span class="title">host</span> &#123;</span></span><br><span class="line">	decl_lck_mtx_data(,lock)		<span class="comment">/* lock to protect exceptions */</span></span><br><span class="line">	<span class="keyword">ipc_port_t</span> special[HOST_MAX_SPECIAL_PORT + <span class="number">1</span>];</span><br><span class="line">	<span class="class"><span class="keyword">struct</span> <span class="title">exception_action</span> <span class="title">exc_actions</span>[<span class="title">EXC_TYPES_COUNT</span>];</span></span><br><span class="line">&#125;;</span><br></pre></td></tr></table></figure>

<h3 id="时钟对象（Clock）"><a href="#时钟对象（Clock）" class="headerlink" title="时钟对象（Clock）"></a>时钟对象（Clock）</h3><p>Mach内核提供了一个简单的“时钟”对象（在osfmk/kern/clock.h中定义）的抽象，这个对象用于计时和闹铃，期中最重要的内部API是clock_deadline_for_periodic_event（），调度器通过它设置了一个重复发生的通知–从而保证了多任务引擎的运转。</p>
<h3 id="处理器对象（Processer）"><a href="#处理器对象（Processer）" class="headerlink" title="处理器对象（Processer）"></a>处理器对象（Processer）</h3><p>在多核架构中每一个核心都可以看做是一个CPU，处理器被分配给处理器集，处理器是CPU的简单抽象，被Mach用于一些基本的操作，比如：启动和关闭一个CPU，向CPU分发要执行的线程。结构的定义（在osfmk/kern/processor.h）如下：</p>
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br></pre></td><td class="code"><pre><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">processor</span> &#123;</span></span><br><span class="line">	<span class="keyword">queue_chain_t</span>		processor_queue;<span class="comment">/* idle/active queue link,</span></span><br><span class="line"><span class="comment">										 * MUST remain the first element */</span></span><br><span class="line">	<span class="keyword">int</span>					state;			<span class="comment">/* See below */</span></span><br><span class="line">	<span class="keyword">boolean_t</span>		is_SMT;</span><br><span class="line">	<span class="keyword">boolean_t</span>		is_recommended;</span><br><span class="line">	<span class="class"><span class="keyword">struct</span> <span class="title">thread</span></span></span><br><span class="line"><span class="class">						*<span class="title">active_thread</span>,	/* <span class="title">thread</span> <span class="title">running</span> <span class="title">on</span> <span class="title">processor</span> */</span></span><br><span class="line"><span class="class">						*<span class="title">next_thread</span>,	/* <span class="title">next</span> <span class="title">thread</span> <span class="title">when</span> <span class="title">dispatched</span> */</span></span><br><span class="line"><span class="class">						*<span class="title">idle_thread</span>;</span>	<span class="comment">/* this processor&#x27;s idle thread. */</span></span><br><span class="line">	<span class="keyword">processor_set_t</span>		processor_set;	<span class="comment">/* assigned set */</span></span><br><span class="line">	<span class="keyword">int</span>					current_pri;	<span class="comment">/* priority of current thread */</span></span><br><span class="line">	<span class="keyword">sched_mode_t</span>		current_thmode;	<span class="comment">/* sched mode of current thread */</span></span><br><span class="line">	<span class="keyword">sfi_class_id_t</span>		current_sfi_class;	<span class="comment">/* SFI class of current thread */</span></span><br><span class="line">	<span class="keyword">int</span>					cpu_id;			<span class="comment">/* platform numeric id */</span></span><br><span class="line">	<span class="keyword">timer_call_data_t</span>	quantum_timer;	<span class="comment">/* timer for quantum expiration */</span></span><br><span class="line">	<span class="keyword">uint64_t</span>			quantum_end;	<span class="comment">/* time when current quantum ends */</span></span><br><span class="line">	<span class="keyword">uint64_t</span>			last_dispatch;	<span class="comment">/* time of last dispatch */</span></span><br><span class="line">	<span class="keyword">uint64_t</span>			deadline;		<span class="comment">/* current deadline */</span></span><br><span class="line">	<span class="keyword">boolean_t</span>               first_timeslice;                <span class="comment">/* has the quantum expired since context switch */</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">if</span> defined(CONFIG_SCHED_TRADITIONAL) || defined(CONFIG_SCHED_MULTIQ)</span></span><br><span class="line">	<span class="class"><span class="keyword">struct</span> <span class="title">run_queue</span>	<span class="title">runq</span>;</span>			<span class="comment">/* runq for this processor */</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">endif</span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">if</span> defined(CONFIG_SCHED_TRADITIONAL)</span></span><br><span class="line">	<span class="keyword">int</span>					runq_bound_count; <span class="comment">/* # of threads bound to this processor */</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">endif</span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">if</span> defined(CONFIG_SCHED_GRRR)</span></span><br><span class="line">	<span class="class"><span class="keyword">struct</span> <span class="title">grrr_run_queue</span>	<span class="title">grrr_runq</span>;</span>      <span class="comment">/* Group Ratio Round-Robin runq */</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">endif</span></span></span><br><span class="line">	<span class="keyword">processor_t</span>			processor_primary;	<span class="comment">/* pointer to primary processor for</span></span><br><span class="line"><span class="comment">											 * secondary SMT processors, or a pointer</span></span><br><span class="line"><span class="comment">											 * to ourselves for primaries or non-SMT */</span></span><br><span class="line">	<span class="keyword">processor_t</span>		processor_secondary;</span><br><span class="line">	<span class="class"><span class="keyword">struct</span> <span class="title">ipc_port</span> *	<span class="title">processor_self</span>;</span>	<span class="comment">/* port for operations */</span></span><br><span class="line">	<span class="keyword">processor_t</span>			processor_list;	<span class="comment">/* all existing processors */</span></span><br><span class="line">	<span class="keyword">processor_data_t</span>	processor_data;	<span class="comment">/* per-processor data */</span></span><br><span class="line">&#125;;</span><br></pre></td></tr></table></figure>
<p>其中最重要的是runq，这是分发到这个处理器的线程队列。</p>
<h3 id="处理器集"><a href="#处理器集" class="headerlink" title="处理器集"></a>处理器集</h3><p>处理器集就是一个或多个processor_t的分组，也被称为pset。pset通常维护三个队列：</p>
<p>active_queue：用于保存当前正在执行线程的CPU。<br>idle_queue：用于保存当前空闲的CPU（例如：正在执行idle_thread）。<br>pset_runq：保存了在这个集合中的所有CPU上执行的线程。<br>processor_set的定义如下：</p>
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br></pre></td><td class="code"><pre><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">processor_set</span> &#123;</span></span><br><span class="line">	<span class="keyword">queue_head_t</span>		active_queue;	<span class="comment">/* active processors */</span></span><br><span class="line">	<span class="keyword">queue_head_t</span>		idle_queue;		<span class="comment">/* idle processors */</span></span><br><span class="line">	<span class="keyword">queue_head_t</span>		idle_secondary_queue;		<span class="comment">/* idle secondary processors */</span></span><br><span class="line">	<span class="keyword">int</span>					online_processor_count;</span><br><span class="line">	<span class="keyword">int</span>					cpu_set_low, cpu_set_hi;</span><br><span class="line">	<span class="keyword">int</span>					cpu_set_count;</span><br><span class="line"><span class="meta">#<span class="meta-keyword">if</span> __SMP__</span></span><br><span class="line">	decl_simple_lock_data(,sched_lock)	<span class="comment">/* lock for above */</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">endif</span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">if</span> defined(CONFIG_SCHED_TRADITIONAL) || defined(CONFIG_SCHED_MULTIQ)</span></span><br><span class="line">	<span class="class"><span class="keyword">struct</span> <span class="title">run_queue</span>	<span class="title">pset_runq</span>;</span>      <span class="comment">/* runq for this processor set */</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">endif</span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">if</span> defined(CONFIG_SCHED_TRADITIONAL)</span></span><br><span class="line">	<span class="keyword">int</span>					pset_runq_bound_count;</span><br><span class="line">		<span class="comment">/* # of threads in runq bound to any processor in pset */</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">endif</span></span></span><br><span class="line">	<span class="comment">/* CPUs that have been sent an unacknowledged remote AST for scheduling purposes */</span></span><br><span class="line">	<span class="keyword">uint64_t</span>			pending_AST_cpu_mask;</span><br><span class="line"><span class="meta">#<span class="meta-keyword">if</span> defined(CONFIG_SCHED_DEFERRED_AST)</span></span><br><span class="line">	<span class="comment">/*</span></span><br><span class="line"><span class="comment">	 * A seperate mask, for ASTs that we may be able to cancel.  This is dependent on</span></span><br><span class="line"><span class="comment">	 * some level of support for requesting an AST on a processor, and then quashing</span></span><br><span class="line"><span class="comment">	 * that request later.</span></span><br><span class="line"><span class="comment">	 *</span></span><br><span class="line"><span class="comment">	 * The purpose of this field (and the associated codepaths) is to infer when we</span></span><br><span class="line"><span class="comment">	 * no longer need a processor that is DISPATCHING to come up, and to prevent it</span></span><br><span class="line"><span class="comment">	 * from coming out of IDLE if possible.  This should serve to decrease the number</span></span><br><span class="line"><span class="comment">	 * of spurious ASTs in the system, and let processors spend longer periods in</span></span><br><span class="line"><span class="comment">	 * IDLE.</span></span><br><span class="line"><span class="comment">	 *\/</span></span><br><span class="line"><span class="comment">	uint64_t			pending_deferred_AST_cpu_mask;</span></span><br><span class="line"><span class="comment">#endif</span></span><br><span class="line"><span class="comment">	struct ipc_port	*	pset_self;		/* port for operations */</span></span><br><span class="line">	<span class="class"><span class="keyword">struct</span> <span class="title">ipc_port</span> *	<span class="title">pset_name_self</span>;</span>	<span class="comment">/* port for information */</span></span><br><span class="line">	<span class="keyword">processor_set_t</span>		pset_list;		<span class="comment">/* chain of associated psets */</span></span><br><span class="line">	<span class="keyword">pset_node_t</span>			node;</span><br><span class="line">&#125;;</span><br></pre></td></tr></table></figure>


      
    </div>

    
    
    
      <footer class="post-footer">
        <div class="post-eof"></div>
      </footer>
  </article>
  
  
  

      
  
  
  <article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-CN">
    <link itemprop="mainEntityOfPage" href="https://wangkejie.gitee.io/blogwebpage/iOS/kernelarchitecture/overview.html">

    <span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
      <meta itemprop="image" content="/blogwebpage/images/avatar.gif">
      <meta itemprop="name" content="Jack Wang">
      <meta itemprop="description" content="书山有路勤为径，学海无涯苦作舟！">
    </span>

    <span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
      <meta itemprop="name" content="王科杰">
    </span>
      <header class="post-header">
        <h2 class="post-title" itemprop="name headline">
          
            <a href="/blogwebpage/iOS/kernelarchitecture/overview.html" class="post-title-link" itemprop="url">苹果内核架构</a>
        </h2>

        <div class="post-meta">
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-calendar"></i>
              </span>
              <span class="post-meta-item-text">发表于</span>

              <time title="创建时间：2019-07-14 11:26:39" itemprop="dateCreated datePublished" datetime="2019-07-14T11:26:39+08:00">2019-07-14</time>
            </span>
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-folder"></i>
              </span>
              <span class="post-meta-item-text">分类于</span>
                <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
                  <a href="/blogwebpage/categories/iOS/" itemprop="url" rel="index"><span itemprop="name">iOS</span></a>
                </span>
                  ，
                <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
                  <a href="/blogwebpage/categories/iOS/%E8%8B%B9%E6%9E%9C%E5%86%85%E6%A0%B8%E6%9E%B6%E6%9E%84/" itemprop="url" rel="index"><span itemprop="name">苹果内核架构</span></a>
                </span>
            </span>

          

        </div>
      </header>

    
    
    
    <div class="post-body" itemprop="articleBody">

      
          <p><span class="exturl" data-url="aHR0cHM6Ly9kZXZlbG9wZXIuYXBwbGUuY29tL2xpYnJhcnkvYXJjaGl2ZS9kb2N1bWVudGF0aW9uL0Rhcndpbi9Db25jZXB0dWFsL0tlcm5lbFByb2dyYW1taW5nL0FyY2hpdGVjdHVyZS9BcmNoaXRlY3R1cmUuaHRtbA==">官方文档地址<i class="fa fa-external-link-alt"></i></span> </p>
<h1 id="OS-X简介"><a href="#OS-X简介" class="headerlink" title="OS X简介"></a>OS X简介</h1><p>OS X为Macintosh用户和开发人员社区提供了许多好处。这些优点包括改进的可靠性和性能、增强的网络特性、基于对象的系统编程接口以及对行业标准的更多支持。</p>
<p>在创建OS X的过程中，苹果彻底改造了Mac OS核心操作系统。形成OS X的基础是内核。下图说明了OS X体系结构。</p>
<img src="/blogwebpage/images/iOS/osxlayers.png" class="" title="osxlayers">

<p>内核为OS x提供了许多增强功能，包括抢占、内存保护、增强的性能、改进的网络设施、对Macintosh(扩展版和标准版)和非Macintosh (UFS、ISO 9660等等)文件系统的支持、面向对象的api等等。其中两个特性，抢占和内存保护，导致了更健壮的环境。</p>
<p>在Mac OS 9中，应用程序协作共享处理器时间。类似地，所有应用程序之间共享计算机的内存。Mac OS 9是一个协作的多任务环境。如果一个应用程序不合作，那么所有进程的响应性都会受到影响。另一方面，实时应用程序(如多媒体)需要保证具有可预测的、时间关键的行为。</p>
<p>相比之下，OS X是一个先发制人的多任务环境。在OS X中，内核提供了强制合作，调度进程来共享时间(抢占)。这支持需要实时行为的应用程序。</p>
<p>在OS X中，进程通常不共享内存。相反，内核为每个进程分配自己的地址空间，控制对这些地址空间的访问。此控件确保任何应用程序都不能无意中访问或修改另一个应用程序的内存(保护)。规模不是问题;由于OS X包含了虚拟内存系统，每个应用程序都可以访问自己的4 GB地址空间。</p>
<p>从整体上看，所有应用程序都在用户空间中运行，但这并不意味着它们共享内存。用户空间只是所有用户级应用程序的组合地址空间的术语。内核本身有它自己的地址空间，称为内核空间。在OS X中，没有应用程序可以直接修改系统软件(内核)的内存。</p>
<p>虽然默认情况下用户进程不像Mac OS 9那样共享内存，但应用程序之间的通信(甚至内存共享)仍然是可能的。例如，内核提供了一组丰富的原语，允许进程之间共享一些信息。这些基本类型包括共享库、框架和POSIX共享内存。<code>Mach消息传递提供了另一种方法，将内存从一个进程传递到另一个进程。</code>然而，与Mac OS 9不同的是，如果没有程序员的显式操作，内存共享就无法实现。</p>
<h1 id="达尔文操作系统"><a href="#达尔文操作系统" class="headerlink" title="达尔文操作系统"></a>达尔文操作系统</h1><p><code>OS X内核是一个开源项目</code>。内核以及OS X的其他核心部分<code>统称为Darwin</code>。Darwin是一个完整的操作系统，基于与OS x相同的许多技术。但是，Darwin不包括Apple专有的图形或应用程序层，比如Quartz、QuickTime、Cocoa、Carbon或OpenGL。</p>
<p>下图显示了Darwin和OS X之间的关系，它们都构建在相同的内核之上，但是OS X添加了核心服务、应用程序服务和QuickTime，以及经典的Carbon、Cocoa和Java (JDK)应用程序环境。Darwin和OS X都包含BSD命令行应用程序环境;然而，在OS X中，不需要使用环境，因此它对用户是隐藏的，除非用户选择访问它。</p>
<img src="/blogwebpage/images/iOS/darwinlayers.png" class="" title="darwinlayers">

<p>Darwin技术基于BSD、Mach 3.0和苹果技术。最重要的是，<code>Darwin技术是开源技术</code>，这意味着开发人员可以完全访问源代码。实际上，OS X第三方开发人员可以成为Darwin核心系统软件开发团队的一部分。开发人员还可以看到苹果在核心操作系统中是如何工作的，并在自己的产品中采用(或调整)代码。有关详细信息，请参阅Apple公共源许可证(APSL)。</p>
<p>因为相同的软件构成了OS X和Darwin的核心，所以开发人员可以创建在OS X和Darwin上运行的底层软件，而<code>几乎不需要进行任何更改</code>。唯一的区别可能是软件与应用程序环境的交互方式。</p>
<p>达尔文是基于许多来源的成熟技术。这项技术的很大一部分来自FreeBSD，这是4.4BSD的一个版本，提供了先进的网络、性能、安全和兼容性特性。该系统软件的其他部分，如Mach，基于苹果MkLinux项目、OS X服务器以及NeXT收购的技术。大部分代码与平台无关。所有核心操作系统代码都以源代码的形式提供。</p>
<p>选择核心技术有几个原因。<code>Mach提供了一组干净的抽象，用于处理内存管理、进程间(和处理器间)通信(IPC)和其他低级操作系统功能。</code>在当今快速变化的硬件环境中，这在操作系统和底层硬件之间提供了一个有用的隔离层。</p>
<p>BSD是一个精心设计的成熟操作系统，具有许多功能。事实上，当今大多数商业UNIX和类UNIX操作系统都包含大量BSD代码。BSD还提供了一组行业标准api。</p>
<p>新技术，如I/O工具包和网络内核扩展(NKEs)，都是由苹果公司设计和设计的，以利用先进的功能，如面向对象编程模型提供的功能。OS X将这些新技术与经过时间检验的行业标准结合起来，创建了一个稳定、可靠、灵活和可扩展的操作系统。</p>
<h1 id="系统架构"><a href="#系统架构" class="headerlink" title="系统架构"></a>系统架构</h1><p>Darwin和OS X的基础层由几个体系结构组件组成，如下图所示。这些组件合在一起构成内核环境。</p>
<img src="/blogwebpage/images/iOS/osxarchitecture.png" class="" title="osxarchitecture">
<blockquote>
<p>重要提示:注意OS X使用术语内核的方式与您可能期望的有所不同。</p>
</blockquote>
<p>在传统的操作系统术语中，内核是一个很小的软件核心，它只提供实现附加操作系统服务所需的最小设施。——摘自《4.4 BSD操作系统的设计与实现》，McKusick, Bostic, Karels和Quarterman, 1996。</p>
<p>类似地，在传统的基于Mach的操作系统中，内核指的是Mach微内核，忽略了额外的底层代码，没有这些底层代码，Mach几乎做不了什么。</p>
<p>然而，在OS X中，内核环境包含的内容比Mach内核本身多得多。<code>OS X内核环境包括Mach内核、BSD、I/O工具包、文件系统和网络组件。这些通常统称为内核</code>。下面几节将简要描述这些组件。有关进一步的详细信息，请参阅具体的组成部分章节或参考书目中列出的参考资料。</p>
<p>因为OS X包含三个基本组件(<code>Mach、BSD和I/O工具包</code>)，所以对于某些关键操作，常常有多达三个api。一般来说，所选择的API应该与正在使用它的内核部分匹配，而内核部分又由您的代码试图执行的操作决定。本章的其余部分将介绍Mach、BSD和I/O工具包，并概述这些组件提供的功能。</p>
<h2 id="Mach"><a href="#Mach" class="headerlink" title="Mach"></a>Mach</h2><p>Mach管理CPU使用情况和内存等处理器资源，处理调度，提供内存保护，并为其他操作系统层提供以消息为中心的基础设施。</p>
<p>参看我的另外一篇<a href="./iOS/kernelarchitecture/mach.html">Mach概览一章</a></p>
<p>Mach组件提供</p>
<ul>
<li>无类型进程间通信(IPC)</li>
<li>远程过程调用(RPC)</li>
<li>对称多处理(SMP)的调度程序支持</li>
<li>对实时服务的支持</li>
<li>虚拟内存支持</li>
<li>支持寻呼机</li>
<li>模块化的体系结构</li>
</ul>
<p>有关Mach的一般信息可以在<a href="./iOS/kernelarchitecture/mach.html">Mach概览一章</a>中找到。有关调度的信息可以在<code>Mach调度和线程接口</code>一章中找到。有关VM系统的信息可以在<span class="exturl" data-url="aHR0cHM6Ly9kZXZlbG9wZXIuYXBwbGUuY29tL2xpYnJhcnkvYXJjaGl2ZS9kb2N1bWVudGF0aW9uL0Rhcndpbi9Db25jZXB0dWFsL0tlcm5lbFByb2dyYW1taW5nL3ZtL3ZtLmh0bWwjLy9hcHBsZV9yZWYvZG9jL3VpZC9UUDMwMDAwOTA1LUNIMjEwLUJFSEpERkNB">内存和虚拟内存<i class="fa fa-external-link-alt"></i></span>中找到。</p>
<h2 id="BSD"><a href="#BSD" class="headerlink" title="BSD"></a>BSD</h2><p>在Mach层之上，BSD层提供“OS personality”api和服务。BSD层基于BSD内核，主要是FreeBSD。BSD组件提供</p>
<ul>
<li>文件系统</li>
<li>联网(硬件设备级除外)</li>
<li>UNIX的安全模型</li>
<li>系统调用的支持</li>
<li>BSD过程模型，包括过程id和信号</li>
<li>FreeBSD内核api</li>
<li>许多POSIX api</li>
<li>对pthreads (POSIX线程)的内核支持</li>
</ul>
<p>BSD组件在<span class="exturl" data-url="aHR0cHM6Ly9kZXZlbG9wZXIuYXBwbGUuY29tL2xpYnJhcnkvYXJjaGl2ZS9kb2N1bWVudGF0aW9uL0Rhcndpbi9Db25jZXB0dWFsL0tlcm5lbFByb2dyYW1taW5nL0JTRC9CU0QuaHRtbCMvL2FwcGxlX3JlZi9kb2MvdWlkL1RQMzAwMDA5MDUtQ0gyMTQtVFBYUkVGMTAx">BSD概述一章<i class="fa fa-external-link-alt"></i></span>中有更详细的描述。</p>
<h2 id="网络"><a href="#网络" class="headerlink" title="网络"></a>网络</h2><p>OS X网络利用BSD的高级网络功能来提供对现代特性的支持，比如网络地址转换(NAT)和防火墙。网络组件提供</p>
<ul>
<li>4.4BSD TCP/IP栈和套接字api</li>
<li>同时支持IP和DDP (AppleTalk传输)</li>
<li>multihoming</li>
<li>路由</li>
<li>多播支持</li>
<li>服务器调优</li>
<li>信息包过滤</li>
<li>Mac OS经典支持(通过过滤器)</li>
</ul>
<p>有关网络的更多信息可以在<span class="exturl" data-url="aHR0cHM6Ly9kZXZlbG9wZXIuYXBwbGUuY29tL2xpYnJhcnkvYXJjaGl2ZS9kb2N1bWVudGF0aW9uL0Rhcndpbi9Db25jZXB0dWFsL0tlcm5lbFByb2dyYW1taW5nL05ldHdvcmtpbmcvTmV0d29ya2luZy5odG1sIy8vYXBwbGVfcmVmL2RvYy91aWQvVFAzMDAwMDkwNS1DSDIxNi1CQUJIQ0hGQw==">网络体系结构一章<i class="fa fa-external-link-alt"></i></span>中找到。</p>
<h2 id="文件系统"><a href="#文件系统" class="headerlink" title="文件系统"></a>文件系统</h2><p>OS X支持多种类型的文件系统，包括HFS、HFS+、UFS、NFS、ISO 9660等。默认的文件系统类型是HFS+;OS X引导(和“根”)来自HFS+、UFS、ISO、NFS和UDF。OS X文件系统的高级功能包括一个增强的虚拟文件系统(VFS)设计。VFS提供了分层的体系结构(文件系统是可堆叠的)。文件系统组件提供</p>
<ul>
<li>utf - 8 (Unicode)支持</li>
<li>与以前版本的Mac OS相比，性能有所提高。</li>
</ul>
<p>更多信息可以在章节<span class="exturl" data-url="aHR0cHM6Ly9kZXZlbG9wZXIuYXBwbGUuY29tL2xpYnJhcnkvYXJjaGl2ZS9kb2N1bWVudGF0aW9uL0Rhcndpbi9Db25jZXB0dWFsL0tlcm5lbFByb2dyYW1taW5nL0ZpbGVzeXN0ZW0vRmlsZXN5c3RlbS5odG1sIy8vYXBwbGVfcmVmL2RvYy91aWQvVFAzMDAwMDkwNS1DSDIxNS1CQUJFRUhGRg==">文件系统概述<i class="fa fa-external-link-alt"></i></span>中找到。</p>
<h2 id="I-O设备"><a href="#I-O设备" class="headerlink" title="I / O设备"></a>I / O设备</h2><p>I/O工具包为简化驱动程序开发提供了一个框架，支持多种类型的设备。I/O工具包提供了一个面向对象的I/O体系结构，该体系结构在c++的一个受限子集中实现。I/O工具包框架是模块化和可扩展的。I/O工具包组件提供</p>
<ul>
<li>真正的即插即用</li>
<li>动态设备管理</li>
<li>动态(按需)加载驱动程序</li>
<li>桌面系统和便携式设备的电源管理</li>
<li>多处理器能力</li>
</ul>
<p>I/O工具包在<span class="exturl" data-url="aHR0cHM6Ly9kZXZlbG9wZXIuYXBwbGUuY29tL2xpYnJhcnkvYXJjaGl2ZS9kb2N1bWVudGF0aW9uL0Rhcndpbi9Db25jZXB0dWFsL0tlcm5lbFByb2dyYW1taW5nL0lPS2l0L0lPS2l0Lmh0bWwjLy9hcHBsZV9yZWYvZG9jL3VpZC9UUDMwMDAwOTA1LUNIMjEzLUJFSEpERkNB">I/O工具包概述一章<i class="fa fa-external-link-alt"></i></span>中有更详细的描述。</p>
<h1 id="内核扩展"><a href="#内核扩展" class="headerlink" title="内核扩展"></a>内核扩展</h1><p>OS X提供了一种内核扩展机制，作为一种允许将代码片段动态加载到内核空间的方法，而不需要重新编译。这些代码通常称为插件<code>plug-ins</code>，或者在OS X内核环境中称为<code>kernel extensions</code>或<code>KEXTs</code>。</p>
<p>因为<code>KEXTs</code>同时提供模块化和动态可加载性，所以对于需要访问不导出到用户空间的接口的任何相对自包含的服务，KEXTs都是一个自然的选择。内核环境的许多组件都支持这种扩展机制，尽管它们以不同的方式支持。</p>
<p>例如，一些新的网络特性涉及到使用网络内核扩展(NKEs)。这些将在<span class="exturl" data-url="aHR0cHM6Ly9kZXZlbG9wZXIuYXBwbGUuY29tL2xpYnJhcnkvYXJjaGl2ZS9kb2N1bWVudGF0aW9uL0Rhcndpbi9Db25jZXB0dWFsL0tlcm5lbFByb2dyYW1taW5nL05ldHdvcmtpbmcvTmV0d29ya2luZy5odG1sIy8vYXBwbGVfcmVmL2RvYy91aWQvVFAzMDAwMDkwNS1DSDIxNi1CQUJIQ0hGQw==">网络体系结构一章<i class="fa fa-external-link-alt"></i></span>讨论。</p>
<p>动态添加新文件系统实现的能力基于VFS KEXTs, I/O工具包中的设备驱动程序和设备族使用KEXTs实现。对于编写驱动程序或编写代码以支持新的卷格式或网络协议的开发人员来说，KEXTs使开发变得更加容易。在<span class="exturl" data-url="aHR0cHM6Ly9kZXZlbG9wZXIuYXBwbGUuY29tL2xpYnJhcnkvYXJjaGl2ZS9kb2N1bWVudGF0aW9uL0Rhcndpbi9Db25jZXB0dWFsL0tlcm5lbFByb2dyYW1taW5nL0V4dGVuZC9FeHRlbmQuaHRtbCMvL2FwcGxlX3JlZi9kb2MvdWlkL1RQMzAwMDA5MDUtQ0gyMjAtQkVCREdGSEk=">内核扩展概述一章<i class="fa fa-external-link-alt"></i></span>中将更详细地讨论KEXTs。</p>

      
    </div>

    
    
    
      <footer class="post-footer">
        <div class="post-eof"></div>
      </footer>
  </article>
  
  
  


  
  <nav class="pagination">
    <span class="page-number current">1</span><a class="page-number" href="/blogwebpage/page/2/">2</a><span class="space">&hellip;</span><a class="page-number" href="/blogwebpage/page/6/">6</a><a class="extend next" rel="next" href="/blogwebpage/page/2/"><i class="fa fa-angle-right" aria-label="下一页"></i></a>
  </nav>



          </div>
          

<script>
  window.addEventListener('tabs:register', () => {
    let { activeClass } = CONFIG.comments;
    if (CONFIG.comments.storage) {
      activeClass = localStorage.getItem('comments_active') || activeClass;
    }
    if (activeClass) {
      let activeTab = document.querySelector(`a[href="#comment-${activeClass}"]`);
      if (activeTab) {
        activeTab.click();
      }
    }
  });
  if (CONFIG.comments.storage) {
    window.addEventListener('tabs:click', event => {
      if (!event.target.matches('.tabs-comment .tab-content .tab-pane')) return;
      let commentClass = event.target.classList[1];
      localStorage.setItem('comments_active', commentClass);
    });
  }
</script>

        </div>
          
  
  <div class="toggle sidebar-toggle">
    <span class="toggle-line toggle-line-first"></span>
    <span class="toggle-line toggle-line-middle"></span>
    <span class="toggle-line toggle-line-last"></span>
  </div>

  <aside class="sidebar">
    <div class="sidebar-inner">

      <ul class="sidebar-nav motion-element">
        <li class="sidebar-nav-toc">
          文章目录
        </li>
        <li class="sidebar-nav-overview">
          站点概览
        </li>
      </ul>

      <!--noindex-->
      <div class="post-toc-wrap sidebar-panel">
      </div>
      <!--/noindex-->

      <div class="site-overview-wrap sidebar-panel">
        <div class="site-author motion-element" itemprop="author" itemscope itemtype="http://schema.org/Person">
    <img class="site-author-image" itemprop="image" alt="Jack Wang"
      src="/blogwebpage/images/avatar.gif">
  <p class="site-author-name" itemprop="name">Jack Wang</p>
  <div class="site-description" itemprop="description">书山有路勤为径，学海无涯苦作舟！</div>
</div>
<div class="site-state-wrap motion-element">
  <nav class="site-state">
      <div class="site-state-item site-state-posts">
          <a href="/blogwebpage/archives/">
        
          <span class="site-state-item-count">52</span>
          <span class="site-state-item-name">日志</span>
        </a>
      </div>
      <div class="site-state-item site-state-categories">
            <a href="/blogwebpage/categories/">
          
        <span class="site-state-item-count">56</span>
        <span class="site-state-item-name">分类</span></a>
      </div>
      <div class="site-state-item site-state-tags">
            <a href="/blogwebpage/tags/">
          
        <span class="site-state-item-count">54</span>
        <span class="site-state-item-name">标签</span></a>
      </div>
  </nav>
</div>
  <div class="links-of-author motion-element">
      <span class="links-of-author-item">
        <span class="exturl" data-url="aHR0cHM6Ly9naXRodWIuY29tL0phY2stVmluZw==" title="GitHub → https:&#x2F;&#x2F;github.com&#x2F;Jack-Ving"><i class="github fa-fw"></i>GitHub</span>
      </span>
      <span class="links-of-author-item">
        <span class="exturl" data-url="bWFpbHRvOjcyNzg4MTk0NUBxcS5jb20=" title="E-Mail → mailto:727881945@qq.com"><i class="envelope fa-fw"></i>E-Mail</span>
      </span>
  </div>



      </div>

    </div>
  </aside>
  <div id="sidebar-dimmer"></div>


      </div>
    </main>

    <footer class="footer">
      <div class="footer-inner">
        

        
  <div class="beian"><span class="exturl" data-url="aHR0cHM6Ly9iZWlhbi5taWl0Lmdvdi5jbg==">京ICP备16036665号-2 </span>
  </div>

<div class="copyright">
  
  &copy; 
  <span itemprop="copyrightYear">2021</span>
  <span class="with-love">
    <i class="heart"></i>
  </span>
  <span class="author" itemprop="copyrightHolder">Jack Wang</span>
</div>
  <div class="powered-by">由 <span class="exturl theme-link" data-url="aHR0cHM6Ly9oZXhvLmlv">Hexo</span> & <span class="exturl theme-link" data-url="aHR0cHM6Ly90aGVtZS1uZXh0Lm9yZw==">NexT.Gemini</span> 强力驱动
  </div>

        


  <div style="display: none;">
    <script src="//s95.cnzz.com/z_stat.php?id=1277804316&web_id=1277804316"></script>
  </div>






      </div>
    </footer>
  </div>

  
  <script src="/blogwebpage/lib/anime.min.js"></script>
  <script src="/blogwebpage/lib/velocity/velocity.min.js"></script>
  <script src="/blogwebpage/lib/velocity/velocity.ui.min.js"></script>

<script src="/blogwebpage/js/utils.js"></script>

<script src="/blogwebpage/js/motion.js"></script>


<script src="/blogwebpage/js/schemes/pisces.js"></script>


<script src="/blogwebpage/js/next-boot.js"></script>




  
  <script>
    (function(){
      var canonicalURL, curProtocol;
      //Get the <link> tag
      var x=document.getElementsByTagName("link");
		//Find the last canonical URL
		if(x.length > 0){
			for (i=0;i<x.length;i++){
				if(x[i].rel.toLowerCase() == 'canonical' && x[i].href){
					canonicalURL=x[i].href;
				}
			}
		}
    //Get protocol
	    if (!canonicalURL){
	    	curProtocol = window.location.protocol.split(':')[0];
	    }
	    else{
	    	curProtocol = canonicalURL.split(':')[0];
	    }
      //Get current URL if the canonical URL does not exist
	    if (!canonicalURL) canonicalURL = window.location.href;
	    //Assign script content. Replace current URL with the canonical URL
      !function(){var e=/([http|https]:\/\/[a-zA-Z0-9\_\.]+\.baidu\.com)/gi,r=canonicalURL,t=document.referrer;if(!e.test(r)){var n=(String(curProtocol).toLowerCase() === 'https')?"https://sp0.baidu.com/9_Q4simg2RQJ8t7jm9iCKT-xh_/s.gif":"//api.share.baidu.com/s.gif";t?(n+="?r="+encodeURIComponent(document.referrer),r&&(n+="&l="+r)):r&&(n+="?l="+r);var i=new Image;i.src=n}}(window);})();
  </script>




  
<script src="/blogwebpage/js/local-search.js"></script>













  

  
  <script src="//cdn.jsdelivr.net/npm/quicklink@1/dist/quicklink.umd.js"></script>
  <script>
      window.addEventListener('load', () => {
      quicklink({
        timeout : 3000,
        priority: true,
        ignores : [uri => uri.includes('#'),uri => uri === 'https://wangkejie.gitee.io/blogwebpage/',]
      });
      });
  </script>

</body>
</html>
